web-dev-qa-db-fra.com

Variables statiques dans les fonctions membres

Quelqu'un peut-il s'il vous plaît expliquer comment les variables statiques dans les fonctions membres fonctionnent en C++.

Étant donné la classe suivante:

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

Si je déclare plusieurs instances de A, appeler foo() sur une instance incrémente la variable statique i sur toutes les instances? Ou seulement celui auquel il a été appelé?

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

c++staticscope
145
monofonik

Puisque class A Est une classe non-template et que A::foo() est une fonction non-template. Il n'y aura qu'une seule copie de static int i À l'intérieur du programme.

Toute instance de A object affectera le même i et la durée de vie de i restera à travers le 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
152
iammilind

Le mot clé static a malheureusement quelques significations différentes et non liées 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 des instances.

  2. Lorsqu'il est utilisé 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'à la fermeture du programme. De plus, la variable n'est visible que dans la fonction. Cette particularité de la statique locale est souvent utilisée pour la construction paresseuse de singletons.

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

J'ai mis l'accent sur la partie la plus importante pour chaque utilisation. Use (3) est quelque peu découragé au profit d'espaces de noms non nommés qui permettent également des déclarations de classe non exportées.

Dans votre code, le mot clé static est utilisé avec le sens 2 et n'a rien à voir avec des classes ou des instances ... il s'agit d'une variable de la fonction fonction et il n'y aura qu'une seule copie. de cela.

Comme correctement iammilind, cependant, il aurait pu y avoir plusieurs occurrences de cette variable si la fonction était une fonction modèle (car dans ce cas, la fonction elle-même peut être présente dans de nombreuses copies différentes du programme). Même dans ce cas, les cours et les instances ne sont pas pertinents ... 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;
}
128
6502