C++: salva il valore variabile per il prossimo richiamo della funzione

Question

C'è un modo per inizializzare una variabile in una funzione e salvare il suo valore per la prossima chiamata di funzione?

Sto facendo applicazione in qt e ho una funzione connessa con un segnale. Voglio che una variabile in quella funzione cambi dopo che l'altra raggiunge il suo obiettivo. Ecco il corpo di quella funzione:

void objekt::advance(int phase) 
{ 
if(!phase) return; 

QPointF location = this->pos(); 
if (int(location.x())==200 || int(location.x())==-200) 
{ 
    smijer=-smijer; 

} 
setPos(mapToParent(smijer,0)); 
} 

Ho definito la variabile smijer come statica int. Ma non so come inizializzarlo solo una volta, all'avvio del programma, e come mantenere il suo nuovo valore dopo ogni chiamata della funzione.

Answer 1

Se smijer è un membro della classe di objekt, quindi fare in questo modo:

objekt.h:

class objekt 
{ 
    ... 
    static int smijer; 
    ... 
}; 

objekt.cpp

int objekt::smijer = YOUR_INITIALIZATION_VALUE; 

D'altra parte, se vuoi/avere bisogno di smijer per essere una variabile globale, quindi farlo in questo modo:

globals.h:

extern int smijer; 

globals.cpp // o un altro file cpp

int smijer = YOUR_INITIALIZATION_VALUE; 

Anche se in questo caso mi piacerebbe restare in uno spazio dei nomi. In questo caso non è dichiarato statico ma ha la durata del tuo programma.

Answer 2

Dichiarare la variabile come statica all'interno della funzione e il valore verrà ricordato. Non è necessario inizializzarlo. Ma puoi, se vuoi.

Answer 3

Perché sono in downvoted? Vuole cambiare una variabile e preservare gli stati dopo le chiamate di funzione. (Non specifica se la variabile è un membro della classe o qualcosa del genere, quindi suppongo che non lo sia. Cambierò la mia risposta se chiarisce e afferma la sua domanda in modo meno ambiguo.)

Sei andando su questo sbagliato. Per mantenere una variabile al termine dell'ambito di una funzione, è necessario allocarlo sull'heap anziché sullo stack. È possibile utilizzare new o malloc per eseguire questa operazione, ma è anche necessario liberare questa memoria con delete e free, in questo ordine.

Con new e delete:

#include <iostream> 

void modify(int * p){ 
    (*p)++; 
} 

int main(void){ 
    int * pointer = new int; 
    *pointer = 5; 

    std::cout << *pointer << std::endl; 

    modify(pointer); 

    std::cout << *pointer << std::endl; 

    delete pointer; 
    return 0; 
} 

E con malloc e free:

#include <iostream> 
#include <cstdlib> 

void modify(int * p){ 
    (*p)++; 
} 

int main(void){ 
    int * pointer = (int*)malloc(sizeof(int)); //DO NOT CAST IN C 
    *pointer = 5; 

    std::cout << *pointer << std::endl; 

    modify(pointer); 

    std::cout << *pointer << std::endl; 

    free(pointer); 
    return 0;  
} 

new FORNISCE strutture per cancellare le matrici in modo rapido ed è complessivamente migliore per l'utilizzo normale C++.

Answer 4

La tua risposta è fondamentalmente nella tua domanda. Le variabili statiche (un membro della classe o una variabile locale di una funzione) vengono inizializzate solo una volta dove viene terminata.Per esempio;

#include <iostream> 
int foo() { 
    static int sVar = 5; 
    sVar++; 
    return sVar; 
} 

using namespace std; 
int main() { 
    int iter = 0; 
    do { 
     cout << "Svar :" foo() << endl; 
     iter++; 
     }while (iter < 3); 
} 

se si scrive un programma come quello stamperà i valori di Svar proprio come;

Svar :6 
Svar :7 
Svar :8 

Quindi, come si vede, anche se noi chiamiamo funzione foo tre volte l'inizializzazione di un varible statico viene effettuata una sola volta.