Ansi/iso c++ : 003 : variables, globale vs automatique

Soyez le premier à donner votre avis sur cette source.

Snippet vu 8 138 fois - Téléchargée 39 fois

Contenu du snippet

Nous savons que les algorithmes sont organisés sous forme d’instructions au sein de fonctions.
Les informations manipulées par ces algorithmes sont stockées en mémoire sous forme de variable.
Cette zone mémoire doit être :
- allouée : obligé
- initialisée : souvent[1]
- utilisé : pour bien faire[2]
- nettoyée : parfois[3]
- libérée : pour bien faire[4]
En C++, il existe 3 grandes sortes de variable :
- Une variable globale peut être accessible de partout (toute fonctions).
Elle est allouée et initialisé automatiquement avant l’entré dans la fonction 'main'.
Elle est nettoyée et libérée automatiquement après la sortie de la fonction 'main'.
- Une variable locale (dite également automatique) est visible dans le block d’instructions dans lequel elle à été déclaré et ce, à partir de sa déclaration.
Elle est allouée et initialisée lorsque le thread traite sa déclaration/initialisation.
Elle est nettoyée et libérée automatiquement, lorsque le thread sort du block d’instructions dans lequel elle a été déclaré, quelque soit les circonstances de la sortie du block ('return', exception, …) [5].
- Une variable d’allocation dynamique est totalement contrôlée par le programmeur. Nous parlerons plus tard de ce type de variable dite de bas niveau. C’est à dire pas utilisé couramment ou alors indirectement à travers des variables globales ou automatiques.

Source / Exemple :


#include <iostream>

extern int g_a; // déclaration seul

void mettre_zero();

void sortir();

int main()
{ // block "corp de la fonction main"
   using namespace std;

   sortir();

   mettre_zero();

   sortir();

   { // block A

      float b;

      b = 3.14159265359;

      cout << "b = " << b << endl;

   } // block A

   { // block B
      int c = 365;

      { // block B,A

         int c = 69;

         cout << "c = " << c << endl;

         g_a += c;

         sortir();

      } // block B,A

      cout << "c = " << c << endl;

      g_a += c;

      sortir();

   } // block B

   cin.ignore( 1, '\n');
}

void mettre_zero()
{
   using namespace std;

   g_a = 0;

   cout << "mise à zero de g_a" << endl;
}

void sortir()
{
   using namespace std;

   cout << "g_a = " << g_a << endl;
}

int g_a = 5; // déclaration et initialisation

Conclusion :


Ici,
nous incluons la définition des flux d’entrées-sorties.
Nous déclarons l’existance d’une variable globale identifiée "g_a", dont les valeurs sont de type entier.
Nous déclarons 2 fonctions qui ne retournent rien et ne reçoivent aucun argument, identifié "mettre_zero" et "sortir".
Pour info, les déclarations peuvent être redondantes, apparaître plusieurs fois dans un même code parcouru par le compilateur.
En suite, nous déclarons et définissons la fonction principale (point d’entré) "main".
Dans cette fonction, nous déclarons utiliser, par défaut, les objets standard.
Nous appelons la fonction "sortir" puis la fonction "mettre_zero" puis encore "sortir", notez bien l’ordre …
Dans un premier block, que nous appelons "A", nous déclarons une variable automatique identifiée "b", que nous initialisons en suite avec la valeur "3.14159265359". Nous envoyons vers la sortie "b = " suivi de la valeur de "b". Fin du block A : "b" n’existe plus.
...
Nous terminons en définissant le corps des fonctions "mettre_zero" et "sortir" puis, déclarer et initialiser la variable globale "g_a".

[1] : Entendez par initialiser, donner une première valeur à la variable. Une fois allouée, le contenu de la zone mémoire n’est pas défini en C++. La première chose à faire est donc l’écriture de quelque chose dans la variable.
Pour des types de variable complexe, comme des objets (instances de classes), il est possible de définir un algorithme lié à cet événement. Cet algorithme est une fonction appelée constructeur.

[2] : Parfois, les algorithmes liés à l’initialisation (constructeur) et au nettoyage (destructeur) constituent une utilisation en soit de la variable. Cette technique est très utilisée avec les variables locales (automatiques).

[3] : J’entends par nettoyage l’exécution d’un algorithme lié à l’événement que constitue la disparition de la variable. Cela concerne uniquement les variables de type objet (instances de classes). La fonction en question est appelée destructeur.

[4] : L’espace mémoire est rendu disponible, pour d’autres usages.

[5] : C’est l’aspect le plus intéressant de ce type de variable.

A voir également

Vous n'êtes pas encore membre ?

inscrivez-vous, c'est gratuit et ça prend moins d'une minute !

Les membres obtiennent plus de réponses que les utilisateurs anonymes.

Le fait d'être membre vous permet d'avoir un suivi détaillé de vos demandes et codes sources.

Le fait d'être membre vous permet d'avoir des options supplémentaires.