int statica in funzione

Question

mi sono imbattuto in questo codice:

void function(int nextFoo) 
{ 
    static int lastFoo = nextFoo; 
    if (nextFoo != lastFoo) 
    { 
     // is this possible? 
    } 
    lastFoo = nextFoo; 
} 

Il codificatore pensa che lastFoo è impostato solo nel primo periodo, e l'ultima riga, è lui giusto? Penso (ma non lo so) che il codice nel blocco if non viene mai eseguito, ma non riesce a trovarlo.

Answer 1

Il coder pensa che nextFoo sia impostato solo nella prima esecuzione e che l'ultima sia giusta?

Sì. static le variabili locali vengono inizializzate solo una volta (e non tutte le volte che si inserisce la funzione). In C++ 11, questo è garantito anche in modo thread-safe. Per punto 6.7/4 del C++ 11 standard:

[...] Se il controllo entra dichiarazione contemporaneamente mentre viene inizializzata la variabile, l'esecuzione concorrente deve attendere completamento dell'inizializzazione [ ...]

avviso, che se l'inizializzazione dell'oggetto static genera un'eccezione, la sua inizializzazione sarà nuovamente tentato la prossima volta function() viene inserito (non rilevante in questo caso, dato che l'inizializzazione di un int non può buttare). Dallo stesso punto citato:

[...] Se le uscite di inizializzazione di un'eccezione, l'inizializzazione non è completa, in modo che saranno processati di nuovo il controllo del tempo successivo entra nella dichiarazione. [...]

Answer 2

Ovviamente è possibile. L'inizializzazione statica avviene solo una volta. La prossima volta che chiami la funzione, l'inizializzazione non viene più eseguita.

(In realtà, l'inizializzazione :-) pari-corsa libera.)

Answer 3

Il codice nel blocco può corsa; L'esempio seguente stampa hello:

#include <iostream> 

using namespace std; 

void function(int nextFoo) 
{ 
    static int lastFoo=nextFoo; 
    if (nextFoo!=lastFoo) 
    { 
     cout << "hello" << endl; 
    } 
    lastFoo=nextFoo; 
} 

int main() 
{ 
    function(1); 
    function(2); 

    return 0; 
} 

Answer 4

La semplice risposta è che sì lastFoo sarà impostato solo la prima volta qui:

static int lastFoo=nextFoo; 

ma questo sarebbe stato sufficiente come un test per scoprire come funzionava per te. Naturalmente, alla fine della funzione lastFoo verrà stabilito dal l'assegnazione finale:

#include <iostream> 

void function(int nextFoo) 
{ 
    static int lastFoo=nextFoo; 

    std::cout << "lastFoo: " << lastFoo << std::endl ; 

    if (nextFoo!=lastFoo) 
    { 
     std::cout << "here" << std::endl ; 
    } 
    lastFoo=nextFoo; 
} 

int main() 
{ 
    function(10) ; 
    function(11) ; 

} 

Answer 5

statica è una classe di memoria e dice al compilatore che la variabile non è una variabile automatica che viene creato/distrutto ogni volta che il la la funzione è inserita e lasciata.

Da K & R C Programming Language (2a edizione)

A4.1 classe di memoria

Ci sono due classi di memoria: automatica e statiche

...

oggetti statici possono essere locali ad un blocco o esterno a tutti i blocchi, ma in entrambi i casi mantengono i loro valori di tutti esci da e rientri in funzioni e blocchi.

Quindi sì, la dichiarazione if è totalmente legittima. La variabile potrebbe avere un valore diverso quando viene richiamata la funzione.