Variables estáticas en funciones miembro

¿Alguien puede explicar cómo funcionan las variables estáticas en las funciones miembro en C ++?

Dada la siguiente clase:

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

Si declaro varias instancias de A, ¿llamar foo()a una instancia incrementa la variable estática ien todas las instancias? ¿O solo el que fue llamado?

Supuse que cada instancia tendría su propia copia i, pero al pasar por algún código que tengo parece indicar lo contrario.

Dado que class Aes una clase sin plantilla y A::foo()es una función sin plantilla. Solo habrá una copia del static int iprograma.

Cualquier instancia de Aobjeto afectará lo mismo iy la vida útil de ipermanecerá durante todo el programa. Para agregar un ejemplo:

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

La palabra clave staticdesafortunadamente tiene algunos significados diferentes no relacionados en C ++

1. Cuando se usa para miembros de datos significa que los datos se asignan en la clase y no en instancias.

2. Cuando se usa para datos dentro de una función, significa que los datos se asignan estáticamente, se inicializan la primera vez que se ingresa el bloque y duran hasta que se cierra el programa. Además, la variable solo es visible dentro de la función. Esta característica especial de las estadísticas locales a menudo se usa para implementar la construcción perezosa de singletons.

3. Cuando se usa en un nivel de unidad de compilación (módulo) significa que la variable es como una global (es decir, asignada e inicializada antes de mainejecutarse y destruirse después de las mainsalidas) pero que la variable no será accesible ni visible en otras unidades de compilación .

Agregué énfasis en la parte que es más importante para cada uso. Se desaconseja el uso (3) a favor de espacios de nombres sin nombre que también permiten declaraciones de clase no exportadas.

En su código, la staticpalabra clave se usa con el significado número 2 y no tiene nada que ver con clases o instancias ... es una variable de la función y solo habrá una copia de ella.

Como dijo correctamente iammilind , sin embargo, podría haber habido múltiples instancias de esa variable si la función fuera una función de plantilla (porque en ese caso, de hecho, la función en sí misma puede estar presente en muchas copias diferentes en el programa). Incluso en ese caso, por supuesto, las clases y las instancias son irrelevantes ... vea el siguiente ejemplo:

#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 estáticas dentro de funciones

• La variable estática se crea dentro de una función que se almacena en la memoria estática del programa, no en la pila.

• La inicialización de la variable estática se realizará en la primera llamada de la función.

• La variable estática retendrá el valor en múltiples llamadas a funciones

• La vida útil de la variable estática es Programa

Ejemplos

#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;
}

Salida:

Variable estática

Valor variable: 0
Valor variable: 1
Valor variable: 2
Valor variable: 3
Valor variable: 4

Variable automática

Valor variable: 0
Valor variable: 0
Valor variable: 0
Valor variable: 0
Valor variable: 0

Respuesta simplificada:

Las variables estáticas, independientemente de si son miembros de una función (sin plantilla) classo una función (sin plantilla), se comportan, técnicamente, como una etiqueta global cuyo alcance está limitado a la classfunción o.