C++: zapisz wartość zmiennej dla następnego wywołania funkcji

Question

Czy istnieje sposób inicjalizacji zmiennej w funkcji i zapisania jej wartości dla następnego wywołania funkcji?

Robię aplikację w qt i mam jedną funkcję połączoną z sygnałem. Chcę, aby zmienna w tej funkcji zmieniała się, gdy druga osiągnie swój cel. Oto ciało tej funkcji:

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

Zdefiniowałem zmienną smijer jako statyczną int. Ale nie wiem, jak zainicjować go tylko raz, kiedy program się uruchomi i jak zachować jego nową wartość po każdym wywołaniu funkcji.

Answer 1

Jeśli smijer jest członkiem klasy objekt, to zrób to tak:

objekt.h:

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

objekt.cpp

int objekt::smijer = YOUR_INITIALIZATION_VALUE; 

Z drugiej strony, jeśli chcesz/potrzebujesz smijer jako zmiennej globalnej, a następnie wykonaj to w ten sposób:

globals.h:

extern int smijer; 

globals.cpp // lub inny plik .cpp

int smijer = YOUR_INITIALIZATION_VALUE; 

Chociaż w tym przypadku będę trzymać go w obszarze nazw. W tym przypadku nie jest zadeklarowany jako statyczny, ale ma żywotność twojego programu.

Answer 2

Zadeklaruj zmienną jako statyczną wewnątrz funkcji, a wartościowane zostaną zapamiętane. Nie musisz go inicjować. Ale możesz, jeśli chcesz.

Answer 3

Dlaczego przyznano mi obniżkę? Chce zmienić zmienną i zachować stany po wywołaniach funkcji. (Nie określa, czy zmienna jest członkiem klasy, czy cokolwiek innego, więc zakładam, że tak nie jest.) Zmienię swoją odpowiedź, jeśli wyjaśni i stwierdzi mniej jednoznacznie swoje pytanie.)

Jesteś o tym źle. Aby zachować zmienną po zakończeniu zakresu funkcji, trzeba go przydzielić na stercie, a nie na stosie. Możesz użyć do tego celu new lub malloc, ale musisz również zwolnić tę pamięć za pomocą delete i free, w tej kolejności.

Z new i 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; 
} 

I z malloc i 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 ma stwarzać możliwość szybkiego usuwania tablic i jest ogólnie lepsze dla normalnego użytkowania C++.

Answer 4

Twoja odpowiedź jest zasadniczo w twoim pytaniu. Zmienne statyczne (element członkowski klasy lub zmienna lokalna funkcji) inicjowane są tylko raz, gdy są zakończone.Na przykład;

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

jeśli napiszesz taki program, to wydrukuje wartości Svar, takie jak;

Svar :6 
Svar :7 
Svar :8 

Tak jak widzisz, chociaż trzy razy nazywamy funkcję foo, inicjalizacja statycznej zmiennej jest wykonywana tylko raz.