Programmation en C++ – Les classes de stockage

Une classe de stockage définit la portée (visibilité) et la durée de vie des variables et / ou des fonctions dans un programme C++. Ils précèdent le type qu’ils modifient. Nous avons quatre classes de stockage différentes dans un programme C++ :
 
 

• auto
• register
• static
• extern

La classe de stockage auto

C’est la classe de stockage par défaut. Il s’applique uniquement aux variables locales et la variable n’est visible que dans la fonction dans laquelle elle est déclarée et se détruit dès que l’exécution de la fonction est terminée. Exemple :

{
   int mois;  // par défaut, la classe de stockage est auto
   auto int mois;
}

 

La classe de stockage register

La classe de stockage register est utilisée pour définir des variables locales qui doivent ê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 d’adresse & appliqué sur elle (car il n’a pas d’emplacement de mémoire).

{
   register int  miles;
}

Le registre ne doit être utilisé que pour les variables nécessitant un accès rapide, comme les compteurs. Il convient également de noter que la déclaration d’une variable avec le mot-clé register ne signifie pas que la variable sera stockée dans un registre. Cela signifie qu’il pourrait être stocké dans un registre en fonction du matériel et des restrictions d’implémentation.
 

La classe de stockage static

La classe de stockage static demande au compilateur de conserver une variable locale en existence pendant la durée de vie du programme au lieu de la créer et de la détruire à chaque fois qu’elle entre et sort de son champ d’application. Par conséquent, rendre les variables statiques leur permet de maintenir leurs valeurs entre les appels de fonction.

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

En programmation C++, lorsque le mot-clé static est utilisé sur un membre de données d’une classe, il ne fait que partager une seule copie de ce membre avec tous les objets de sa classe.

#include <iostream>
using namespace std; 

/* Déclaration de fonction */
void func(void);
 
static int c = 5; /* Variable globale */
 
main() {

   while(c--) {
      func();
   }
 
   return 0;
}

/* Définition de fonction */
void func( void ) {

   static int i = 5; /* Variable statique locale */
   i++;

   cout << "i = "<< i << "et c = "<<  c <<endl;
}

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

i = 6 et c = 4
i = 7 et c = 3
i = 8 et c = 2
i = 9 et c = 1
i = 10 et c = 0

 
 

La classe de stockage extern

Les variables de la classe de stockage extern ont une portée globale. Nous utilisons des variables externes lorsque nous voulons qu’une variable soit visible en dehors du fichier dans lequel elle est déclarée. Ainsi, une variable externe peut être partagée entre plusieurs fichiers. Une variable externe reste active tant que l’exécution du programme se poursuit. Une variable globale static n’est visible que dans le fichier où elle est déclarée, mais une variable globale extern est visible dans tous les fichiers d’un programme.

Le modificateur externe est le plus couramment utilisé lorsqu’il existe deux ou plusieurs fichiers partageant les mêmes variables globales ou fonctions comme expliqué ci-dessous.
 

Fichier 1 :

#include <iostream>
using namespace std;
 
int c ;
extern void read();
 
main() {

   c = 5;
   read();
}

Fichier 2 :

#include <iostream>
using namespace std;
 
extern int c;
 
void read(void) {
   cout << "c = "<< c <<endl;
}  

Compiler les deux fichiers:

$gcc main.c compter.c

Lorsque le programme est exécuté, il produit le résultat suivant

c = 5

 

La classe de stockage mutable

La classe de stockage mutable est utilisé uniquement sur un membre de données d’une classe pour le rendre modifiable même si le membre fait partie d’un objet déclaré comme ‘const’. Vous ne pouvez pas utiliser le spécificateur mutable avec les membres déclarés comme ‘static’, ‘const’, ou sur les références.

Exemple :

#include <iostream>
using namespace std;

class TestMut {
	public:
		int x;
		mutable int y;
		
		TestMut() {
			x = 9; 
			y = 25; 
		}
};
int main()
{
	const TestMut test;
	test.y = 30;
	cout << test.y;
	return 0;
}

La sortie :

30