1. Qu'est-ce que static ?

static est un modificateur très couramment utilisé en C/C++. Il est utilisé pour contrôler le mode de stockage et la visibilité des variables.

1.1 Introduction de static

Nous savons que pour les variables définies à l'intérieur d'une fonction, lorsque le programme s'exécute jusqu'à leur définition, le compilateur leur alloue de l'espace sur la pile. L'espace alloué sur la pile par la fonction sera libéré lorsque la fonction aura terminé son exécution. Cela pose un problème : si vous voulez conserver la valeur de cette variable dans la fonction jusqu'à l'appel suivant, comment y parvenir ? La méthode la plus simple à laquelle on pense est de la définir comme variable globale, mais définir une variable globale présente de nombreux inconvénients. L'inconvénient le plus évident est que cela détruit la portée d'accès de la variable (ce qui fait que la variable définie dans cette fonction n'est plus contrôlée uniquement par cette fonction). Le mot-clé static peut très bien résoudre ce problème.

De plus, en C++, lorsqu'un objet de données doit servir l'ensemble de la classe plutôt qu'un objet spécifique, tout en s'efforçant de ne pas briser l'encapsulation de la classe, c'est-à-dire lorsque le membre doit être caché à l'intérieur de la classe et invisible de l'extérieur, il peut être défini comme donnée statique.

1.2 Stockage des données statiques

Zone de stockage globale (statique): Elle est divisée en segment DATA et segment BSS. Le segment DATA (zone globale initialisée) stocke les variables globales initialisées et les variables statiques ; le segment BSS (zone globale non initialisée) stocke les variables globales non initialisées et les variables statiques. Ils sont automatiquement libérés lorsque le programme se termine. Parmi eux, le segment BSS sera automatiquement mis à 0 par le système avant l'exécution du programme, de sorte que les variables globales non initialisées et les variables statiques valent déjà 0 avant l'exécution du programme. Les variables stockées dans la zone de données statiques terminent leur initialisation lorsque le programme commence à s'exécuter pour la première fois, et c'est la seule initialisation.

Mécanisme d'implémentation interne de static en C++ : les membres de données statiques doivent exister dès que le programme commence à s'exécuter. Comme les fonctions sont appelées pendant l'exécution du programme, les membres de données statiques ne peuvent pas se voir allouer de l'espace et être initialisés à l'intérieur d'une fonction.

Ainsi, il y a trois emplacements possibles pour son allocation d'espace : premièrement, le fichier d'en-tête en tant qu'interface externe de la classe, où se trouve la déclaration de classe ; deuxièmement, l'implémentation interne de la définition de classe, où se trouvent les définitions des fonctions membres de la classe ; troisièmement, la déclaration et la définition de données globales avant la fonction main() de l'application.

Les membres de données statiques doivent réellement allouer de l'espace, ils ne peuvent donc pas être définis dans la déclaration de classe (seuls les membres de données peuvent être déclarés). La déclaration de classe déclare uniquement la « taille et les spécifications » d'une classe et n'effectue pas d'allocation mémoire réelle, donc écrire une définition dans la déclaration de classe est incorrect. Ils ne peuvent pas non plus être définis en dehors de la déclaration de classe dans un fichier d'en-tête, car cela entraînerait des définitions répétées de celui-ci dans plusieurs fichiers source qui utilisent la classe.

static est introduit pour indiquer au compilateur de stocker les variables dans la zone de stockage statique du programme plutôt que sur la pile. Les membres de données statiques sont initialisés dans l'ordre dans lequel ils sont définis. Notez que lorsque des membres statiques sont imbriqués, il est nécessaire de s'assurer que les membres imbriqués ont déjà été initialisés. L'ordre de destruction est l'inverse de l'ordre d'initialisation.

Avantages :Cela permet d'économiser de la mémoire, car il est partagé par tous les objets. Par conséquent, pour plusieurs objets, les membres de données statiques sont stockés à un seul endroit et partagés par tous les objets. La valeur d'un membre de données statique est la même pour chaque objet, mais sa valeur peut être mise à jour. Tant que la valeur du membre de données statique est mise à jour une fois, tous les objets sont assurés d'accéder à la même valeur mise à jour, ce qui peut améliorer l'efficacité temporelle.


2. Le rôle de static en C/C++

2.1 En général

  • (1) Lors de la modification de variables, la variable locale statique modifiée par static n'est initialisée qu'une seule fois, et elle prolonge la durée de vie de la variable locale, qui n'est pas libérée tant que le programme n'a pas fini de s'exécuter.
  • (2) Lorsque static modifie une variable globale, cette variable globale ne peut être accessible que dans le fichier courant et ne peut pas être accessible dans d'autres fichiers, même avec une déclaration externe extern.
  • (3) Si static modifie une fonction, cette fonction ne peut être appelée que dans le fichier courant et ne peut pas être appelée par d'autres fichiers. Les variables modifiées par static sont stockées dans la zone des variables statiques de la zone de données globales, y compris les variables globales statiques et les variables locales statiques, qui allouent toutes de la mémoire dans la zone de données globales. Elles sont automatiquement initialisées à 0 lors de l'initialisation.
  • (4) Lorsque vous ne voulez pas qu'elle soit libérée, vous pouvez utiliser static pour la modifier. Par exemple, modifiez un tableau stocké dans l'espace de pile dans une fonction. Si vous ne voulez pas que le tableau soit libéré à la fin de l'appel de la fonction, vous pouvez utiliser static pour le modifier.
  • (5) Tenez compte de la sécurité des données (lorsque le programme veut utiliser des variables globales, il devrait d'abord envisager d'utiliser static).

2.2 Variables statiques et variables ordinaires

Les variables globales statiques ont les caractéristiques suivantes :

  • (1) Les variables statiques allouent toutes de la mémoire dans la zone de données globales, y compris les variables locales statiques mentionnées plus tard ;
  • (2) Les variables globales statiques non initialisées seront automatiquement initialisées à 0 par le programme (la valeur des variables automatiques déclarées à l'intérieur du corps d'une fonction est aléatoire à moins qu'elle ne soit explicitement initialisée, et les variables automatiques déclarées à l'extérieur du corps de la fonction seront également initialisées à 0) ;
  • (3) Les variables globales statiques sont visibles dans tout le fichier dans lequel elles sont déclarées, et sont invisibles en dehors de ce fichier.

Avantages :Les variables globales statiques ne peuvent pas être utilisées par d'autres fichiers ; d'autres fichiers peuvent définir des variables portant le même nom sans conflit.

(1) La différence entre les variables globales et les variables globales statiques

  • 1) Les variables globales sont des variables globales non explicitement modifiées avec static. Les variables globales ont par défaut une liaison externe, et leur portée est l'ensemble du projet. Une variable globale définie dans un fichier peut être utilisée dans un autre fichier en déclarant 'extern nom de variable globale'.
  • 2) Les variables globales statiques sont des variables globales explicitement modifiées avec static. Leur portée est le fichier dans lequel la variable est déclarée. Les autres fichiers ne peuvent pas les utiliser, même avec une déclaration extern.

2.3 Les variables locales statiques ont les caractéristiques suivantes :

  • (1) Cette variable alloue de la mémoire dans la zone de données globales ;
  • (2) Une variable locale statique est initialisée pour la première fois lorsque le programme atteint la déclaration de l'objet, c'est-à-dire que les appels de fonction suivants ne l'initialiseront plus ;
  • (3) Les variables locales statiques sont généralement initialisées à la déclaration. S'il n'y a pas d'initialisation explicite, elles seront automatiquement initialisées à 0 par le programme ;
  • (4) Elle réside toujours dans la zone de données globales jusqu'à la fin de l'exécution du programme. Mais sa portée est une portée locale. Lorsque la fonction ou le bloc d'instructions qui la définit se termine, sa portée se termine également.

Généralement, les programmes stockent les données dynamiques nouvellement générées dans la zone du tas, et les variables automatiques à l'intérieur des fonctions dans la zone de pile. Les variables automatiques libèrent généralement l'espace lorsque la fonction se termine. Les données statiques (même les variables locales statiques à l'intérieur des fonctions) sont également stockées dans la zone de données globales. Les données de la zone de données globales ne sont pas libérées à cause de la fin d'une fonction.

Regardez l'exemple suivant :

Exemple

//exemple : #include <stdio.h> #include <stdlib.h> int k1 = 1; int k2; static int k3 = 2; static int k4; int main() { static int m1 = 2, m2; int i = 1; char*p; char str[10] = "hello"; char*q = "hello"; p = (char *)malloc(100); free(p); printf("Zone de pile - adresse de variable i: %p\n", &i); printf("Zone de pile - adresse de variable p: %p\n", &p); printf("Zone de pile - adresse de variable str: %p\n", str); printf("Zone de pile - adresse de variable q: %p\n", &q); printf("Adresse de la zone de tas - allocation dynamique: %p\n", p); printf("Global externe avec valeur initiale k1: %p\n", &k1); printf("Externe sans valeur initiale k2: %p\n", &k2); printf("Statique externe avec valeur initiale k3 : %p\n", &k3); printf("Externe statique sans valeur initiale k4 : %p\n", &k4); printf("Statique interne avec valeur initiale m1 : %p\n", &m1); printf("Statique interne sans valeur initiale m2 : %p\n", &m2); printf("Adresse du littéral de chaîne : %p, %s\n", q, q); printf("Adresse de la zone de programme : %p\n", &main); return 0; }

Le résultat de sortie est le suivant :


3. Utilisation de static

3.1 En C++

L'utilisation la plus élémentaire du mot-clé static est :

  • 1. Les variables modifiées par static appartiennent aux variables de classe et peuvent être directement référencées parClass name.variable name, directement y faire référence, sans avoir besoin de new une classe.
  • 2. Les méthodes modifiées par static appartiennent aux méthodes de classe et peuvent être directement référencées parClass name.method name, directement y faire référence, sans avoir besoin de new une classe.

Les variables modifiées par static et les méthodes modifiées par static appartiennent collectivement aux ressources statiques de la classe et sont partagées entre les instances de la classe. En d'autres termes, si cela change à un endroit, cela change partout.

En C++, les membres statiques appartiennent à la classe entière plutôt qu'à un objet spécifique. Les variables membres statiques ne sont stockées qu'une seule fois pour que tous les objets les partagent. Par conséquent, elles peuvent être partagées entre tous les objets. L'utilisation de variables membres statiques pour réaliser le partage de données entre plusieurs objets ne rompt pas le principe de masquage, assure la sécurité et économise de la mémoire.

La définition ou la déclaration des membres statiques doit inclure le mot-clé static. Les membres statiques peuvent être utilisés via le double deux-points, c'est-à-dire,<class name>::<static member name>。

3.2 Relatif aux classes statiques

Appel des fonctions membres statiques et non statiques via le nom de la classe :
class Point { public: void init() { } static void output() { } }; void main() { Point::init(); Point::output(); }

Error:

'Point::init' : illegal call of non-static member function

Conclusion 1 :Les fonctions membres non statiques d'une classe ne peuvent pas être appelées via le nom de la classe.

Appeler des fonctions membres statiques et des fonctions membres non statiques via un objet de la classe.

class Point { public: void init() { } static void output() { } }; void main() { Point pt; pt.init(); pt.output(); }

La compilation passe.

Conclusion 2: Les objets de la classe peuvent utiliser des fonctions membres statiques et des fonctions membres non statiques.

Utilisation de membres non statiques de la classe dans une fonction membre statique de la classe.

#include <stdio.h> class Point { public: void init() { } static void output() { printf("%d\n", m_x); } private: int m_x; }; void main() { Point pt; pt.output(); }

Erreur de compilation :

error C2597: illegal reference to data member 'Point::m_x' in a static member function

Parce qu'une fonction membre statique appartient à la classe entière, et que l'espace lui est alloué avant que la classe n'instancie un objet, tandis qu'un membre non statique de la classe ne peut avoir d'espace mémoire qu'après l'instanciation d'un objet, cet appel produit une erreur. C'est comme utiliser une variable avant qu'elle n'ait été déclarée.

Conclusion 3:Les membres non statiques ne peuvent pas être référencés dans les fonctions membres statiques.

Utilisation de membres statiques de la classe dans des fonctions membres non statiques de la classe.

class Point { public: void init() { output(); } static void output() { } }; void main() { Point pt; Pt.init(); pt.output(); }

La compilation passe.

Conclusion 4: Les fonctions membres non statiques d'une classe peuvent appeler des fonctions membres statiques, mais l'inverse n'est pas possible.

Utilisation des variables membres statiques de la classe.

#include <stdio.h> class Point { public: Point() { m_nPointCount++; } ~Point() { m_nPointCount--; } static void output() { printf("%d\n", m_nPointCount); } private: static int m_nPointCount; }; void main() { Point pt; pt.output(); }

appuyez surCtrl+F7La compilation ne présente aucune erreur, mais une erreur de liaison est signalée lorsque vous appuyez sur F7 pour générer le programme EXE.

error LNK2001: unresolved external symbol "private: static int Point::m_nPointCount" (?m_nPointCount@Point@@0HA)

C'est parce que les variables membres statiques de la classe doivent être initialisées avant utilisation.

Dansmain()Ajoutez avant la fonctionint Point::m_nPointCount = 0;Compilez et liez à nouveau sans erreurs, et l'exécution du programme affichera 1.

Conclusion 5: Les variables membres statiques d'une classe doivent être initialisées avant utilisation.

Résumé de la réflexion :Les ressources statiques appartiennent à la classe, mais existent indépendamment de la classe. Du point de vue du mécanisme de chargement de la classe J, les ressources statiques sont chargées lors de l'initialisation de la classe, tandis que les ressources non statiques sont chargées lorsque la classe instancie un objet. L'initialisation de la classe est antérieure à l'instanciation de la classe ; par exemple,Class.forName("xxx")une méthode initialise une classe mais n'instancie pas d'objet ; elle charge uniquement les ressources statiques de la classe. Par conséquent, pour les ressources statiques, il est impossible de savoir quelles ressources non statiques existent dans une classe. Mais pour les ressources non statiques, c'est différent : parce qu'elles sont produites après l'instanciation d'un objet, elles peuvent reconnaître toutes ces choses qui appartiennent à la classe. Ainsi, les réponses aux questions ci-dessus sont très claires :

  • 1) Les méthodes statiques peuvent-elles faire référence à des ressources non statiques ? Non. Les choses qui ne sont produites que lorsqu'un objet est instancié ne sont tout simplement pas reconnues par les ressources statiques qui existent déjà après l'initialisation.
  • 2) Les ressources statiques peuvent-elles être référencées à l'intérieur des méthodes statiques ? Oui, parce qu'elles sont toutes chargées lors de l'initialisation de la classe, et elles se connaissent toutes.
  • 3) Les ressources statiques peuvent-elles être référencées à l'intérieur de méthodes non statiques ? Oui. Les méthodes non statiques sont des méthodes d'instance, qui ne sont produites qu'après l'instanciation d'un objet, donc elles reconnaissent tout le contenu qui appartient à la classe.

(static modifiant une classe :Cet usage est bien moins courant que les précédents. En général, static ne peut pas modifier une classe. Si static modifie une classe, cela signifie que la classe est une classe interne statique (notez que static ne peut modifier qu'une classe interne), c'est-à-dire une classe interne anonyme. Par exemple, les quatre mécanismes de rejet dans le pool de threads ThreadPoolExecutor—CallerRunsPolicy, AbortPolicy, DiscardPolicy, DiscardOldestPolicy—sont des classes internes statiques. Le contenu lié aux classes internes statiques sera traité spécialement lorsqu'on écrira sur les classes internes.)

3.3 Résumé :

  • (1) Les membres non statiques ne peuvent pas être appelés dans les fonctions membres statiques.
  • (2) Les membres statiques peuvent être appelés dans les fonctions membres non statiques. Parce que les membres statiques appartiennent à la classe elle-même et existent déjà avant qu'un objet de la classe ne soit créé, les membres statiques peuvent être appelés dans les fonctions membres non statiques.
  • (3) Les variables membres statiques doivent être initialisées avant utilisation (par ex.int MyClass::m_nNumber = 0;), sinon une erreur se produira au moment de l'édition de liens.

Résumé général: Dans une classe, static peut être utilisé pour modifier des membres de données statiques et des méthodes membres statiques.

Membres de données statiques

  • (1) Les membres de données statiques peuvent permettre le partage de données entre plusieurs objets. Ce sont des membres partagés de tous les objets de la classe, n'occupant qu'un seul espace en mémoire. Si leur valeur change, la valeur de ce membre de données dans chaque objet change également.
  • (2) De l'espace est alloué aux membres de données statiques lorsque le programme commence à s'exécuter et n'est pas libéré avant la fin du programme. Tant qu'un membre de données statique est spécifié dans la classe, de l'espace lui est alloué même si aucun objet n'est défini.
  • (3) Les membres de données statiques peuvent être initialisés, mais uniquement en dehors du corps de la classe. Si aucune valeur initiale n'est attribuée à un membre de données statique, le compilateur l'initialise automatiquement à 0.
  • (4) Les membres de données statiques peuvent être référencés soit par le nom de l'objet, soit par le nom de la classe.

Fonctions membres statiques

  • (1) Comme les membres de données statiques, les fonctions membres statiques appartiennent aux membres statiques de la classe, et non aux membres d'objet.
  • (2) Les fonctions membres non statiques ont un pointeur this, tandis que les fonctions membres statiques n'ont pas de pointeur this.
  • (3) Les fonctions membres statiques sont principalement utilisées pour accéder aux membres de données statiques et ne peuvent pas accéder aux membres non statiques.

Prenons un autre exemple utilisant des variables et fonctions membres statiques d'une classe pour approfondir la compréhension. Cet exemple crée une classe étudiant. Les objets de la classe étudiant formeront une liste doublement chaînée. Une variable membre statique enregistre la tête de la liste doublement chaînée, et une fonction membre statique affiche cette liste doublement chaînée.

Exemple

#include <stdio.h> #include <string.h> const int MAX_NAME_SIZE = 30; class Student { public: Student(char *pszName); ~Student(); public: static void PrintfAllStudents(); private: char m_name[MAX_NAME_SIZE]; Student *next; Student *prev; static Student *m_head; }; Student::Student(char *pszName) { strcpy(this->m_name, pszName); //Construire une liste doublement chaînée, les nouvelles données sont insérées depuis la tête de la liste. this->next = m_head; this->prev = NULL; if (m_head != NULL) m_head->prev = this; m_head = this; } Student::~Student ()//Le processus de destruction est le processus de détachement des nœuds { if (this == m_head) //Ce nœud est le nœud de tête. { m_head = this->next; } else { this->prev->next = this->next; this->next->prev = this->prev; } } void Student::PrintfAllStudents() { for (Student *p = m_head; p != NULL; p = p->next) printf("%s\n", p->m_name); } Student* Student::m_head = NULL; void main() { Student studentA("AAA"); Student studentB("BBB"); Student studentC("CCC"); Student studentD("DDD"); Student student("MoreWindows"); Student::PrintfAllStudents(); }

Le programme affichera :

Adresse d'origine : https://www.cnblogs.com/33debug/p/7223869.html