Cosa fa la parola chiave statica qui? [chiuso]

La parola chiave static rende la classe di archiviazione dell'intx statico, il che significa che è essenzialmente una variabile globale che ha il suo ambito ambito dalla funzione. In particolare, la durata di x si estende oltre l'esecuzione della funzione e l'inizializzatore viene eseguito solo una volta.

Quando fun () restituisce il riferimento a x nel codice 1, il riferimento punta alla memoria statica per x. Di conseguenza, l'assegnazione a fun () nel set principale imposta la variabile statica da x a 3, che viene poi restituita quando fun () viene richiamata di nuovo sulla riga successiva. Poiché l'inizializzatore per x viene eseguito solo una volta, la seconda chiamata a fun () non reimposta il valore su 10.

L'esempio nel codice 2 non è valido. Restituire un riferimento a una variabile locale non è valido perché la memoria per la variabile locale non esiste dopo il ritorno della funzione. Sebbene possa sembrare che funzioni in questo caso, il risultato di questo codice non è definito. Poiché le variabili locali sono generalmente memorizzate nello stack, per questa specifica sequenza di codice, il valore nella posizione utilizzata per x non è stato spostato nel cestino e il valore viene impostato dall'inizializzatore in fun (). Ma questo è completamente dipendente dall'implementazione e le specifiche del compilatore non garantiscono questo comportamento.

In effetti, se il codice fosse un po 'più complesso, quel valore potrebbe essere stato cestinato e potresti ottenere un valore casuale stampato. O il codice potrebbe persino bloccarsi. In ogni caso non restituire riferimenti o puntatori a variabili locali in quanto non è un codice valido.

Significa che x è condiviso tra le chiamate di funzione. È la funzione equivalente ai membri statici delle classi.

I membri statici sono condivisi tra le istanze mentre le variabili di funzione statiche sono condivise tra le invocazioni. Ciò significa che quando modifichi x dopo la prima chiamata di funzione nell'esempio, rimane modificato per tutte le chiamate future.

int &fun()
{
    static int x = 10; // x is statically allocated at compile time
    int &b =x;         // b is a reference to x
    return b;          // each call to fun() returns a reference to the same int
}
int main()
{
    fun() = 3;         // sets 'x' to 3
    cout << fun();     // it's still 3
    return 0;
}
/////////////////////////////////
int &fun()
{
    int x = 10; // x allocated on the stack whenever f runs
    int &b =x;  // does nothing, b is initialized but never used
    return x;   // undefined behavior.  After fun returns, x does not exist
}
int main()
{
    fun() = 3;  // more undefined behavior
    cout << fun(); // could print any number, or crash
    return 0;
}