Variables statiques dans les fonctions membres

Quelqu'un peut-il expliquer comment les variables statiques dans les fonctions membres fonctionnent en C ++.

Compte tenu de la classe suivante:

class A {
   void foo() {
      static int i;
      i++;
   }
}

Si je déclare plusieurs instances de A, l'appel foo()d'une instance incrémente-t-il la variable statique isur toutes les instances? Ou seulement celui sur lequel il était appelé?

J'ai supposé que chaque instance aurait sa propre copie de i, mais parcourir un certain code que j'ai semble indiquer le contraire.

Depuis class Aest une classe non-modèle et A::foo()une fonction non-modèle. Il n'y aura qu'une seule copie de l' static int iintérieur du programme.

Toute instance d' Aobjet affectera le même iet la durée de vie de irestera tout au long du programme. Pour ajouter un exemple:

A o1, o2, o3;
o1.foo(); // i = 1
o2.foo(); // i = 2
o3.foo(); // i = 3
o1.foo(); // i = 4

Le mot-clé a staticmalheureusement quelques significations différentes et indépendantes en C ++

1. Lorsqu'il est utilisé pour les membres de données, cela signifie que les données sont allouées dans la classe et non dans les instances.

2. Lorsqu'elles sont utilisées pour des données à l'intérieur d'une fonction, cela signifie que les données sont allouées de manière statique, initialisées la première fois que le bloc est entré et dure jusqu'à ce que le programme se ferme. De plus, la variable n'est visible qu'à l'intérieur de la fonction. Cette particularité de la statique locale est souvent utilisée pour implémenter la construction paresseuse de singletons.

3. Lorsqu'elle est utilisée au niveau d'unité de compilation (module), cela signifie que la variable est comme une variable globale (c'est-à-dire allouée et initialisée avant d' mainêtre exécutée et détruite après les mainsorties) mais que la variable ne sera pas accessible ou visible dans d'autres unités de compilation .

J'ai ajouté un peu d'emphase sur la partie la plus importante pour chaque utilisation. Use (3) est quelque peu déconseillé en faveur des espaces de noms sans nom qui permettent également des déclarations de classe non exportées.

Dans votre code, le staticmot-clé est utilisé avec la signification numéro 2 et n'a rien à voir avec les classes ou les instances ... c'est une variable de la fonction et il n'y en aura qu'une copie.

Comme l'a correctement dit iammilind , il aurait pu y avoir plusieurs instances de cette variable si la fonction était une fonction modèle (car dans ce cas, en effet, la fonction elle-même peut être présente dans de nombreuses copies différentes dans le programme). Même dans ce cas, bien sûr, les classes et les instances ne sont pas pertinentes ... voir l'exemple suivant:

#include <stdio.h>

template<int num>
void bar()
{
    static int baz;
    printf("bar<%i>::baz = %i\n", num, baz++);
}

int main()
{
    bar<1>(); // Output will be 0
    bar<2>(); // Output will be 0
    bar<3>(); // Output will be 0
    bar<1>(); // Output will be 1
    bar<2>(); // Output will be 1
    bar<3>(); // Output will be 1
    bar<1>(); // Output will be 2
    bar<2>(); // Output will be 2
    bar<3>(); // Output will be 2
    return 0;
}

Variables statiques à l'intérieur des fonctions

• La variable statique est créée à l'intérieur d'une fonction est stockée dans la mémoire statique du programme et non sur la pile.

• L'initialisation de la variable statique sera effectuée au premier appel de la fonction.

• La variable statique conservera la valeur dans plusieurs appels de fonction

• La durée de vie de la variable statique est Program

Exemples

#include <iostream>

using namespace std;

class CVariableTesting 
{
    public:
    
    void FuncWithStaticVariable();
    void FuncWithAutoVariable();

};

void CVariableTesting::FuncWithStaticVariable()
{
    static int staticVar = 0; //staticVar is initialised by 0 the first time
    cout<<"Variable Value : "<<staticVar<<endl;
    staticVar++;
}
void CVariableTesting::FuncWithAutoVariable()
{
    int autoVar = 0;
    cout<<"Variable Value : "<<autoVar<<endl;
    autoVar++;
}
    

int main()
{
    CVariableTesting objCVariableTesting;
    cout<<"Static Variable";
    objCVariableTesting.FuncWithStaticVariable();
    objCVariableTesting.FuncWithStaticVariable();
    objCVariableTesting.FuncWithStaticVariable();
    objCVariableTesting.FuncWithStaticVariable();
    objCVariableTesting.FuncWithStaticVariable();
    
    cout<<endl;
    cout<<"Auto Variable";
    objCVariableTesting.FuncWithAutoVariable();
    objCVariableTesting.FuncWithAutoVariable();
    objCVariableTesting.FuncWithAutoVariable();
    objCVariableTesting.FuncWithAutoVariable();
    objCVariableTesting.FuncWithAutoVariable();
    
    return 0;
}

Production :

Variable statique

Valeur de la variable: 0
Valeur de la variable: 1
Valeur de la variable: 2
Valeur de la variable: 3
Valeur de la variable: 4

Variable automatique

Valeur de la variable: 0
Valeur de la variable: 0
Valeur de la variable: 0
Valeur de la variable: 0
Valeur de la variable: 0

Réponse simplifiée:

Les variables statiques, qu'elles soient membres d'une fonction (non basée sur classun modèle) ou (sans modèle), se comportent - techniquement - comme une étiquette globale dont la portée est limitée à la classfonction ou.