Variáveis ​​estáticas em funções-membro

Alguém pode explicar como variáveis ​​estáticas em funções membro funcionam em C ++.

Dada a seguinte classe:

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

Se eu declarar várias instâncias de A, a chamada foo()em uma instância incrementa a variável estática iem todas as instâncias? Ou apenas aquele em que foi chamado?

Eu assumi que cada instância teria sua própria cópia i, mas percorrer algum código que parece indicar de outra forma.

Como class Aé uma classe que não é de modelo e A::foo()é uma função que não é de modelo. Haverá apenas uma cópia static int identro do programa.

Qualquer instância do Aobjeto afetará a mesma ie a vida útil ipermanecerá durante todo o programa. Para adicionar um exemplo:

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

staticInfelizmente, a palavra-chave tem alguns significados diferentes não relacionados em C ++

1. Quando usado para membros de dados, significa que os dados são alocados na classe e não nas instâncias.

2. Quando usado para dados dentro de uma função, significa que os dados são alocados estaticamente, inicializados na primeira vez em que o bloco é inserido e perduram até o encerramento do programa. Além disso, a variável é visível apenas dentro da função. Esse recurso especial da estática local é frequentemente usado para implementar a construção lenta de singletons.

3. Quando usada no nível da unidade de compilação (módulo), significa que a variável é como uma global (ou seja, alocada e inicializada antes de mainser executada e destruída após as mainsaídas), mas que a variável não estará acessível ou visível em outras unidades de compilação .

Eu adicionei alguma ênfase na parte que é mais importante para cada uso. Use (3) é um pouco desencorajado em favor de namespaces não nomeados, que também permitem declarações de classe não exportadas.

No seu código, a staticpalavra-chave é usada com o significado número 2 e não tem nada a ver com classes ou instâncias ... é uma variável da função e haverá apenas uma cópia dela.

Como corretamente iammilind disse, no entanto, poderia haver várias instâncias dessa variável se a função fosse uma função de modelo (porque nesse caso, de fato, a própria função pode estar presente em muitas cópias diferentes do programa). Mesmo nesse caso, é claro que as classes e instâncias são irrelevantes ... veja o seguinte exemplo:

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

Variáveis ​​estáticas dentro de funções

• A variável estática é criada dentro de uma função armazenada na memória estática do programa e não na pilha.

• A inicialização da variável estática será feita na primeira chamada da função.

• A variável estática reterá o valor em várias chamadas de função

• A vida útil da variável estática é Program

Exemplos

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

Resultado :

Variável estática

Valor variável: 0
Valor variável: 1
Valor variável: 2
Valor variável: 3
Valor variável: 4

Variável automática

Valor variável: 0
Valor variável: 0
Valor variável: 0
Valor variável: 0
Valor variável: 0

Resposta simplificada:

As variáveis ​​estáticas, independentemente de serem membros de uma função (sem modelo) classou (sem modelo), comportam-se - tecnicamente - como um rótulo global cujo escopo é limitado à classfunção ou.