Classe de stockage C++

classe de stockage automatique

auto la classe de stockage 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é que dans les fonctions, c'est-à-dire que auto ne peut modifier que les variables locales.

classe de stockage de registre

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

{
   register int  miles;
}

Les registres ne sont utilisés que pour les variables auxquelles il faut accéder rapidement, telles que les compteurs. Il convient également de noter que définir « registre » ne signifie pas que la variable sera stockée dans un registre, cela signifie que la variable peut être stockée dans un registre, en fonction des limitations du matériel et de l'implémentation.

Classe de stockage statique

static La classe de stockage demande au compilateur de conserver une variable locale active pendant toute la durée de vie du programme, sans nécessiter qu'elle soit utilisée à chaque fois. les entrées et sorties Les domaines sont créés et détruits. Par conséquent, utiliser static pour modifier une variable locale conserve sa valeur entre les appels de fonction. Le modificateur

static peut également être appliqué aux variables globales. Lorsque static est utilisé pour modifier une variable globale, la portée de la variable est limitée au fichier dans lequel elle est déclarée.

En C++, lorsque static est utilisé sur un membre de données de classe, une seule copie du membre sera partagée par tous les objets de la classe.

#include <iostream>
 
// 函数声明 
void func(void);
 
static int count = 10; /* 全局变量 */
 
int main()
{
    while(count--)
    {
       func();
    }
    return 0;
}
// 函数定义
void func( void )
{
    static int i = 5; // 局部静态变量
    i++;
    std::cout << "变量 i 为 " << i ;
    std::cout << " , 变量 count 为 " << count << std::endl;
}

Lorsque le code ci-dessus est compilé et exécuté, il produit les résultats suivants :

变量 i 为 6 , 变量 count 为 9
变量 i 为 7 , 变量 count 为 8
变量 i 为 8 , 变量 count 为 7
变量 i 为 9 , 变量 count 为 6
变量 i 为 10 , 变量 count 为 5
变量 i 为 11 , 变量 count 为 4
变量 i 为 12 , 变量 count 为 3
变量 i 为 13 , 变量 count 为 2
变量 i 为 14 , 变量 count 为 1
变量 i 为 15 , 变量 count 为 0

classe de stockage externe

extern la classe de stockage est utilisée. Fournit une référence à une variable globale visible par tous les fichiers programme. Lorsque vous utilisez 'extern', pour les variables qui ne peuvent pas être initialisées, le nom de la variable pointe vers un emplacement de stockage préalablement défini.

Lorsque vous avez plusieurs fichiers et définissez une variable globale ou une fonction qui peut être utilisée dans d'autres fichiers, vous pouvez utiliser extern dans d'autres fichiers pour obtenir la variable ou la citation de fonction définie. On comprend que extern est utilisé pour déclarer une variable globale ou une fonction dans un autre fichier. Le

modificateur externe est généralement utilisé lorsqu'il y a deux fichiers ou plus partageant la même variable globale ou fonction, comme indiqué 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 du deuxième fichier est utilisé pour déclarer qu'il est déjà dans le premier fichier main.cpp count défini dans. Maintenant, compilez ces deux fichiers comme suit :

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

Cela produira l'exécutable write Essayez d'exécuter write et cela produira le résultat suivant :

$ ./write
Count is 5

. Le spécificateur

mutable storage class

mutable ne s'applique qu'aux objets de la classe, qui sera expliqué à la fin de ce tutoriel. Il permet aux membres d'un objet de remplacer des constantes. Autrement dit, les membres mutables peuvent être modifiés via les fonctions membres const.