Statische Variablen in Mitgliedsfunktionen

Kann jemand bitte erklären, wie statische Variablen in Mitgliedsfunktionen in C ++ funktionieren.

Gegeben die folgende Klasse:

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

Wenn ich mehrere Instanzen von deklariere A, foo()erhöht der Aufruf einer Instanz die statische Variable iauf allen Instanzen? Oder nur der, auf den es gerufen wurde?

Ich nahm an, dass jede Instanz eine eigene Kopie von haben würde i, aber das Durchgehen eines Codes, den ich habe, scheint etwas anderes anzuzeigen.

Da class Aist eine Nicht-Vorlagenklasse und A::foo()ist eine Nicht-Vorlagenfunktion. Es wird nur eine Kopie static int iim Programm geben.

Jede Instanz eines AObjekts wirkt sich auf dasselbe aus iund die Lebensdauer ibleibt während des gesamten Programms erhalten. So fügen Sie ein Beispiel hinzu:

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

Das Schlüsselwort statichat in C ++ leider einige unterschiedliche Bedeutungen

1. Bei Verwendung für Datenelemente bedeutet dies, dass die Daten in der Klasse und nicht in Instanzen zugewiesen werden .

2. Bei Verwendung für Daten innerhalb einer Funktion bedeutet dies, dass die Daten statisch zugeordnet, beim ersten Eingeben des Blocks initialisiert und bis zum Beenden des Programms gültig sind. Auch die Variable ist nur innerhalb der Funktion sichtbar. Diese Besonderheit der lokalen Statik wird häufig verwendet, um die verzögerte Konstruktion von Singletons zu implementieren.

3. Bei Verwendung auf Ebene der Kompilierungseinheit (Modul) bedeutet dies, dass die Variable wie eine globale Variable ist (dh zugewiesen und initialisiert, bevor sie mainausgeführt und nach dem mainBeenden zerstört wird ), dass die Variable jedoch in anderen Kompilierungseinheiten nicht zugänglich oder sichtbar ist .

Ich habe den Teil hervorgehoben, der für jede Verwendung am wichtigsten ist. Die Verwendung von (3) wird zugunsten nicht benannter Namespaces, von denen auch nicht exportierte Klassendeklarationen möglich sind, etwas abgeraten.

In Ihrem Code wird das staticSchlüsselwort mit der Bedeutung Nummer 2 verwendet und hat nichts mit Klassen oder Instanzen zu tun. Es ist eine Variable der Funktion und es wird nur eine Kopie davon geben.

Wie iammilind richtig sagte, hätte es jedoch mehrere Instanzen dieser Variablen geben können, wenn die Funktion eine Vorlagenfunktion gewesen wäre (da in diesem Fall die Funktion selbst tatsächlich in vielen verschiedenen Kopien im Programm vorhanden sein kann). Auch in diesem Fall sind Klassen und Instanzen natürlich irrelevant ... siehe folgendes Beispiel:

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

Statische Variablen innerhalb von Funktionen

• Die statische Variable wird innerhalb einer Funktion erstellt und im statischen Speicher des Programms gespeichert, nicht auf dem Stapel.

• Die Initialisierung der statischen Variablen erfolgt beim ersten Aufruf der Funktion.

• Die statische Variable behält den Wert in mehreren Funktionsaufrufen bei

• Die Lebensdauer der statischen Variablen beträgt Programm

Beispiele

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

Ausgabe :

Statische Variable

Variabler Wert: 0
Variabler Wert: 1
Variabler Wert: 2
Variabler Wert: 3
Variabler Wert: 4

Automatische Variable

Variablenwert: 0
Variablenwert: 0
Variablenwert: 0
Variablenwert: 0
Variablenwert: 0

Vereinfachte Antwort:

Statische Variablen classverhalten sich - unabhängig davon, ob sie Mitglieder einer Funktion (ohne Vorlage) oder einer Funktion (ohne Vorlage) sind - technisch gesehen - wie eine globale Bezeichnung, deren Gültigkeitsbereich auf die classFunktion oder beschränkt ist.