C++ Classe d'allocation

C ++Chaque variable dans C a deux caractéristiques : type et classe d'allocation.

La spécification de type indique le type de données que peut stocker une variable. Par exemple : int, float, char, etc.

De plus, la classe d'allocation contrôle deux propriétés différentes des variables : le cycle de vie (determinant pendant combien de temps la variable peut exister) et le domaine (determinant quelle partie du programme peut y accéder).

Classe de stockage auto

de C++ 11 depuisauto La clé est utilisée dans deux cas : la déclaration de la variable où le type de la variable est automatiquement déduit à partir de l'expression d'initialisation, et la déclaration de la fonction où le clé est un substitut pour la valeur de retour de la fonction.

C++98La clé auto de la norme est utilisée pour la déclaration de variables automatiques, mais en raison de son utilisation rare et superflue, dans C++11Cette utilisation a été supprimée de la norme.

Le type de la variable déclarée est automatiquement déduit à partir de l'expression d'initialisation, par exemple :

auto f=3.14;　　　　　　//double
auto s("hello");　　//const char*
auto z = new auto(9);　//　int*
auto x1　=　5, x2　=　5.0, x3='r';//Erreur, doit être initialisée avec le même type

Classe de stockage register

register La classe de stockage est utilisée pour définir les variables locales stockées dans un registre plutôt que dans la RAM. Cela signifie que la taille maximale de la variable est égale à la taille du registre (généralement un mot) et qu'il ne peut pas être appliqué à elle l'opérateur unaire '&' (car elle n'a pas d'adresse mémoire).

{
　　　register int miles;
}

Le registre n'est utilisé que pour les variables nécessitant un accès rapide, comme les compteurs. Il convient également de noter que définir 'register' ne signifie pas que la variable sera stockée dans un registre, cela signifie que la variable peut être stockée dans un registre, ce qui dépend des limitations du matériel et de l'implémentation.

Classe de stockage static

static La classe de stockage indique au compilateur de maintenir l'existence des variables locales au cours de la durée de vie du programme, sans nécessiter de création et de destruction à chaque fois qu'elles entrent et quittent leur portée. Par conséquent, l'utilisation du modificateur static pour les variables locales permet de conserver la valeur de la variable entre les appels de fonction.

Le modificateur static peut également être appliqué aux variables globales. Lorsqu'il est utilisé pour modifier une variable globale, il limite l'aire de visibilité de la variable au fichier où elle est déclarée.

Dans C++ dans laquelle, lorsque static est utilisé pour un membre de données de classe, il entraîne qu'il n'y a qu'une seule copie de ce membre partagée par tous les objets de la classe.

#include <iostream>
　
//　Déclaration de la fonction　
void func(void);
　
static int count =　25;　/*　Variable globale　*/
　
int main()
{
　　　　while(count--)
　　　　{
　　　　　　　func();
　　　　}
　　　　return 0;
}
//　Définition de la fonction
void func(void)
{
　　　　static int i =　8;　//　Variable statique locale
　　　　i++;
　　　　std::cout << " variable i vaut " << i;
　　　　std::cout << " , la variable count vaut " << count << std::endl;
}

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

, la variable i vaut　9　, la variable count vaut　24
, la variable i vaut　10　, la variable count vaut　23
, la variable i vaut　11　, la variable count vaut　22
, la variable i vaut　12　, la variable count vaut　21
, la variable i vaut　13　, la variable count vaut　20
, la variable i vaut　14　, la variable count vaut　19
, la variable i vaut　15　, la variable count vaut　18
, la variable i vaut　16　, la variable count vaut　17
, la variable i vaut　17　, la variable count vaut　16
, la variable i vaut　18　, la variable count vaut　15
, la variable i vaut　19　, la variable count vaut　14
, la variable i vaut　20, la variable count vaut　13
, la variable i vaut　21　, la variable count vaut　12
, la variable i vaut　22　, la variable count vaut　11
, la variable i vaut　23　, la variable count vaut　10
, la variable i vaut　24　, la variable count vaut　9
, la variable i vaut　25　, la variable count vaut　8
, la variable i vaut　26　, la variable count vaut　7
, la variable i vaut　27　, la variable count vaut　6
, la variable i vaut　28　, la variable count vaut　5
, la variable i vaut　29　, la variable count vaut　4
, la variable i vaut　30, la variable count vaut　3
, la variable i vaut　31　, la variable count vaut　2
, la variable i vaut　32　, la variable count vaut　1
, la variable i vaut　33　, la variable count vaut 0

Classe de stockage extern

extern La classe de stockage est utilisée pour fournir une référence à une variable globale, visible dans tous les fichiers du programme. Lorsque vous utilisez 'extern', pour les variables non initialisables, le nom de la variable pointe vers une position de stockage définie précédemment.

Lorsque vous avez plusieurs fichiers et que vous avez défini une variable ou une fonction globale utilisable dans d'autres fichiers, vous pouvez utiliser extern Pour obtenir une référence à une variable ou une fonction déjà définie.extern est utilisé pour déclarer une variable ou une fonction globale dans un autre fichier.

Le modificateur extern est généralement utilisé lorsque deux ou plusieurs fichiers partagent la même variable ou fonction globale, comme suit :

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 est " << count << std::endl;
}

Ici, dans le second fichier, extern La clé est utilisée pour déclarer une variable déjà définie dans le fichier main.cpp. Maintenant, compilez ces deux fichiers comme suit :

$ g++　main.cpp support.cpp　-o écrire

Cela produira écrire Exécutable, essayez d'exécuter écrireCela produira le résultat suivant :

$ ./écrire
Count est　5

Classe de stockage mutable

mutable Le modificateur s'applique uniquement aux objets de la classe, ce qui sera expliqué à la fin de ce tutoriel. Il permet aux membres de l'objet de remplacer les constantes. Autrement dit, les membres mutable peuvent être modifiés par des fonctions membres const.

Classe de stockage thread_local

Les variables déclarées avec le modificateur thread_local ne peuvent être accédées que sur le thread sur lequel elles ont été créées. Les variables sont créées lors de la création du thread et détruites lors de la destruction du thread. Chaque thread a sa propre copie de variable.

Le modificateur thread_local peut être combiné avec static ou extern.

thread_local peut être utilisé uniquement pour la déclaration et la définition des données, thread_local ne peut pas être utilisé pour la déclaration ou la définition de la fonction.

Voici un exemple de variables qui peuvent être déclarées comme thread_local:

thread_local int x;　　//　Variables globales dans l'espace de noms
class X
{
　　　　static thread_local std::string s;　//　Variables membres statiques de la classe
};
static thread_local std::string X::s;　　//　X::s doit être définie
　
void foo()
{
　　　　thread_local std::vector<int> v;　　//　Variables locales
}