Variabili statiche nelle funzioni membro

Qualcuno può spiegare come funzionano le variabili statiche nelle funzioni membro in C ++.

Data la seguente classe:

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

Se dichiaro più istanze di A, la chiamata foo()su un'istanza aumenta la variabile statica isu tutte le istanze? O solo quello a cui è stato chiamato?

Supponevo che ogni istanza avrebbe avuto la sua copia di i, ma scorrere un po 'di codice che ho sembra indicare il contrario.

Since class Aè una classe non modello ed A::foo()è una funzione non modello. Ci sarà una sola copia static int iall'interno del programma.

Qualsiasi istanza di Aoggetto influirà sullo stesso ie la durata di vita irimarrà per tutto il programma. Per aggiungere un esempio:

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

La parola chiave staticsfortunatamente ha alcuni significati non correlati in C ++

1. Se utilizzato per i membri dei dati, significa che i dati sono allocati nella classe e non nelle istanze.

2. Se utilizzato per i dati all'interno di una funzione, significa che i dati vengono allocati staticamente, inizializzati la prima volta che il blocco viene inserito e dura fino alla chiusura del programma. Inoltre la variabile è visibile solo all'interno della funzione. Questa caratteristica speciale della statica locale viene spesso utilizzata per implementare la costruzione pigra di singoli.

3. Se utilizzato a livello di unità di compilazione (modulo) significa che la variabile è come un globale (ovvero allocato e inizializzato prima che mainvenga eseguito e distrutto dopo le mainuscite) ma che la variabile non sarà accessibile o visibile in altre unità di compilazione .

Ho aggiunto un po 'di enfasi alla parte che è più importante per ogni uso. Use (3) è in qualche modo scoraggiato a favore di spazi dei nomi senza nome che consentono anche dichiarazioni di classe non esportate.

Nel tuo codice la staticparola chiave viene utilizzata con il significato numero 2 e non ha nulla a che fare con classi o istanze ... è una variabile della funzione e ne rimarrà solo una copia.

Come giustamente ha detto iammilind, tuttavia, se la funzione fosse una funzione modello, potrebbero esserci più istanze di quella variabile (perché in tal caso la funzione stessa può essere presente in molte copie diverse del programma). Anche in questo caso, naturalmente, le lezioni e le istanze sono irrilevanti ... vedere l'esempio seguente:

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

Variabili statiche all'interno delle funzioni

• La variabile statica viene creata all'interno di una funzione memorizzata nella memoria statica del programma non nello stack.

• L'inizializzazione della variabile statica verrà eseguita alla prima chiamata della funzione.

• La variabile statica manterrà il valore in più chiamate di funzione

• La durata della variabile statica è Programma

Esempi

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

Produzione :

Variabile statica

Valore variabile: 0
Valore variabile: 1
Valore variabile: 2
Valore variabile: 3
Valore variabile: 4

Variabile automatica

Valore variabile: 0
Valore variabile: 0
Valore variabile: 0
Valore variabile: 0
Valore variabile: 0

Risposta semplificata:

Le variabili statiche, indipendentemente dal fatto che siano membri di una funzione (non basata su modelli) classo (non basate su modelli), si comportano - tecnicamente - come un'etichetta globale il cui ambito è limitato alla classfunzione o.