Was wird ausgedruckt? 6 6 oder 6 7? Und warum?

void foo()
{
    static int x = 5;
    x++;
    printf("%d", x);
}

int main()
{
    foo();
    foo();
    return 0;
}

Hier gibt es zwei Probleme, Lebensdauer und Geltungsbereich.

Der Gültigkeitsbereich der Variable ist dort, wo der Variablenname zu sehen ist. Hier, x ist nur innerhalb der Funktion sichtbar foo().

Die Lebensdauer einer Variablen ist der Zeitraum, in dem sie existiert. Wenn x wurden ohne das Schlüsselwort definiert staticdie Lebensdauer wäre vom Eintritt in foo() zur Rücksendung von foo(); es würde also bei jedem Anruf auf 5 neu initialisiert werden.

Das Schlüsselwort static Maßnahmen zur Verlängerung der Lebensdauer einer Variablen auf die Lebensdauer des Programms; zB erfolgt die Initialisierung einmal und nur einmal und dann behält die Variable ihren Wert – was auch immer sie geworden ist – über alle zukünftigen Aufrufe bei foo().

Ausgabe: 6 7

Grund: Statische Variable wird nur einmal initialisiert (im Gegensatz zur Auto-Variable) und eine weitere Definition der statischen Variable würde während der Laufzeit umgangen. Und wenn es nicht manuell initialisiert wird, wird es automatisch mit dem Wert 0 initialisiert. So,

void foo() {
    static int x = 5; // assigns value of 5 only once
    x++;
    printf("%d", x);
}

int main() {
    foo(); // x = 6
    foo(); // x = 7
    return 0;
}

Das ist dasselbe wie das folgende Programm:

static int x = 5;

void foo()
{
    x++;
    printf("%d", x);
}

int main()
{
     foo();
     foo();
     return 0;
}

Alles, was das Schlüsselwort static in diesem Programm tut, ist, dass es dem Compiler (im Wesentlichen) mitteilt: „Hey, ich habe hier eine Variable, auf die niemand anderes zugreifen soll, sagen Sie niemandem, dass sie existiert“.

Innerhalb einer Methode teilt das Schlüsselwort static dem Compiler dasselbe wie oben mit, aber auch: „Sagen Sie niemandem, dass dies außerhalb dieser Funktion existiert, es sollte nur innerhalb dieser Funktion zugänglich sein“.

ich hoffe das hilft

6 7

Der Compiler sorgt dafür, dass die statische Variableninitialisierung nicht jedes Mal erfolgt, wenn die Funktion eingegeben wird

Ausgang: 6,7

Grund

Die Erklärung von x ist drinnen foo aber die x=5 Die Initialisierung erfolgt außerhalb von foo!

Was wir hier verstehen müssen, ist das

static int x = 5;

ist nicht dasselbe wie

static int x;
x = 5;

Andere Antworten haben hier die wichtigen Wörter Umfang und Lebensdauer verwendet und darauf hingewiesen, dass der Umfang von x ist ab dem Zeitpunkt seiner Deklaration in der Funktion foo bis zum Ende der Funktion foo. Zum Beispiel habe ich überprüft, indem ich die Deklaration an das Ende der Funktion verschoben habe, und das macht x undeklariert bei der x++; Aussage.

Also die static int x (Geltungsbereich) Teil der Aussage gilt tatsächlich dort, wo Sie ihn irgendwo lesen INNERHALB der Funktion und erst ab da, nicht darüber innerhalb der Funktion.

Jedoch die x = 5 (lebenslang) Teil der Aussage ist Initialisierung der Variablen und passiert AUSSEN der Funktion im Rahmen des Programmladens. Variable x wird mit einem Wert von geboren 5 wenn das Programm lädt.

Ich habe das in einem der Kommentare gelesen: “Außerdem spricht dies nicht den wirklich verwirrenden Teil an, nämlich die Tatsache, dass der Initialisierer bei nachfolgenden Aufrufen übersprungen wird.” Wird bei allen Aufrufen übersprungen. Die Initialisierung der Variablen liegt außerhalb des eigentlichen Funktionscodes.

Der Wert 5 wird theoretisch unabhängig davon gesetzt, ob foo aufgerufen wird oder nicht, obwohl ein Compiler die Funktion möglicherweise wegoptimiert, wenn Sie sie nirgendwo aufrufen. Der Wert 5 sollte in der Variablen stehen, bevor foo überhaupt aufgerufen wird.

Innen foodie Aussage static int x = 5; Es ist unwahrscheinlich, dass überhaupt Code generiert wird.

Ich habe die Adresse gefunden x verwendet, wenn ich eine Funktion setze foo in ein Programm von mir eingefügt und dann (korrekterweise) vermutet, dass dieselbe Stelle verwendet werden würde, wenn ich das Programm erneut ausführen würde. Der Teil-Screenshot unten zeigt das x hat den Wert 5 schon vor dem ersten anruf foo.

Eine statische Variable innerhalb einer Funktion hat eine Lebensdauer, solange Ihr Programm läuft. Es wird nicht jedes Mal zugewiesen, wenn Ihre Funktion aufgerufen wird, und nicht zugewiesen, wenn Ihre Funktion zurückkehrt.

Lesen wir einfach die Wikipedia-Artikel über statische Variablen…

Statische lokale Variablen: Variablen, die innerhalb einer Funktion als statisch deklariert sind, werden statisch zugewiesen, während sie denselben Gültigkeitsbereich wie automatische lokale Variablen haben. Daher sind alle Werte, die die Funktion während eines Aufrufs in ihre statischen lokalen Variablen schreibt, immer noch vorhanden, wenn die Funktion erneut aufgerufen wird.