Comprendre les classes de stockage en C++ : Portée, durée de vie et utilisation

Une classe de stockage définit la portée (visibilité) et la durée de vie des variables et/ou fonctions au sein d'un programme C++. Ces spécificateurs précèdent le type qu'ils modifient. Voici les classes de stockage qui peuvent être utilisées dans un programme C++ :

• auto
• register
• static
• extern
• mutable

La classe de stockage auto

La classe de stockage auto est la classe de stockage par défaut pour toutes les variables locales.

{ 
    int mount; 
    auto int month; 
}

L'exemple ci-dessus définit deux variables avec la même classe de stockage ; auto ne peut être utilisé qu'à l'intérieur des fonctions, c'est-à-dire pour les variables locales.

La classe de stockage register

La classe de stockage register est utilisée pour définir des variables locales qui devraient être stockées dans un registre au lieu de la RAM. Cela signifie que la variable a une taille maximale égale à la taille du registre (généralement un mot) et ne peut pas avoir l'opérateur unaire '&' appliqué (car elle n'a pas d'emplacement mémoire).

{ 
    register int miles; 
}

Le register ne devrait être utilisé que pour les variables nécessitant un accès rapide, comme les compteurs. Il faut aussi noter que définir 'register' ne signifie pas que la variable sera stockée dans un registre. Cela signifie qu'elle POURRAIT l'être selon les restrictions matérielles et d'implémentation.

La classe de stockage static

La classe de stockage static instruit le compilateur de maintenir une variable locale en existence pendant la durée de vie du programme au lieu de la créer et la détruire chaque fois qu'elle entre et sort de portée. Par conséquent, rendre des variables locales statiques permet qu'elles conservent leurs valeurs entre les appels de fonction.

Le modificateur static peut aussi être appliqué aux variables globales. Lorsque cela est fait, cela restreint la portée de cette variable au fichier dans lequel elle est déclarée.

En C++, lorsque static est utilisé sur un membre de données de classe, il fait en sorte qu'une seule copie de ce membre soit partagée par tous les objets de sa classe.

#include <iostream>
// Déclaration de fonction
void func(void);

static int count = 10; /* Variable globale */

int main() {
    while(count--) {
        func();
    }
    return 0;
}

// Définition de fonction
void func(void) {
    static int i = 5; // variable locale statique
    i++;
    std::cout << "i is " << i;
    std::cout << " and count is " << count << std::endl;
}

Lorsque le code ci-dessus est compilé et exécuté, il produit le résultat suivant :

i is 6 and count is 9
i is 7 and count is 8
i is 8 and count is 7
i is 9 and count is 6
i is 10 and count is 5
i is 11 and count is 4
i is 12 and count is 3
i is 13 and count is 2
i is 14 and count is 1
i is 15 and count is 0

La classe de stockage extern

La classe de stockage extern est utilisée pour donner une référence d'une variable globale visible par TOUS les fichiers du programme. Lorsque vous utilisez 'extern', la variable ne peut pas être initialisée car tout ce qu'elle fait est de pointer le nom de variable vers un emplacement de stockage qui a été défini précédemment.

Lorsque vous avez plusieurs fichiers et que vous définissez une variable globale ou une fonction qui sera utilisée dans d'autres fichiers également, alors extern sera utilisé dans un autre fichier pour donner la référence de la variable ou fonction définie. Juste pour comprendre, extern est utilisé pour déclarer une variable globale ou une fonction dans un autre fichier.

Le modificateur extern est le plus couramment utilisé lorsque deux ou plusieurs fichiers partagent les mêmes variables globales ou fonctions comme expliqué ci-dessous.

Premier fichier : main.cpp

#include <iostream>
int count;
extern void write_extern();

int main() {
    count = 5;
    write_extern();
}

Deuxième fichier : support.cpp

#include <iostream>
extern int count;

void write_extern(void) {
    std::cout << "Count is " << count << std::endl;
}

Ici, le mot-clé extern est utilisé pour déclarer count dans un autre fichier. Maintenant, compilez ces deux fichiers comme suit :

$ g++ main.cpp support.cpp -o write

Cela produira le programme exécutable write, essayez d'exécuter write et vérifiez le résultat :

$ ./write
5

La classe de stockage mutable

Le spécificateur mutable s'applique uniquement aux objets de classe, qui sont discutés plus loin dans ce tutoriel. Il permet à un membre d'un objet de surcharger une fonction membre const. C'est-à-dire qu'un membre mutable peut être modifié par une fonction membre const.