Śledź, ile razy funkcja rekurencyjna została wywołana w C++

Question

Próbuję pracować nad programem, który ma funkcję, której parametrem jest wektor ciągu znaków. Chcę używać rekurencyjny na tej funkcji, ale za każdym wywołaniu funkcji, chcę zmienić parametr powiedzieć na przykład

fun(stringArray[i]) 

gdzie i jest liczbą czasie funkcja została wywołana.

Tak więc w prostszy sposób coś takiego jak podążanie. Muszę jednak śledzić, ile razy funkcja zabawy została wykonana.

void fun(){ 
    cout<<hi; 
    if(x!=10) 
    fun() 
} 

int main(){ 

    fun(); 
} 

W tym jednym powiedzmy chcę wydrukować go zaledwie 10 razy, więc chcą mieć varible sumujący, a gdy osiągnie 10, to zatrzyma. Więc co mogę zrobić, aby go śledzić? Próbowałem używać zmiennych globalnych, ale nie działają one z funkcjami. Jakieś sugestie?

Answer 1

widziałem spory bałagan, więc postanowiłem oczyścić rzeczy.

Rozwiązanie 0: statyczna zmienna

Rozważmy kod zaproponowany z lekką modyfikacją

#include<iostream> 
using namespace std; 

void fun() 
{ 
    static int count=1; 
    count++; 
    cout << "fun() is called " << count << " times" << endl; 
    if(count<=10) 
    { 
      fun(); 
    } 
} 

int main() 
{ 
    cout << "first call" << endl; 
    fun(); 
    cout << "second call" << endl; 
    fun(); 
    cout << "third call" << endl; 
    fun(); 
} 

I to jest wyjście:

first call 
fun() is called 2 times 
fun() is called 3 times 
fun() is called 4 times 
fun() is called 5 times 
fun() is called 6 times 
fun() is called 7 times 
fun() is called 8 times 
fun() is called 9 times 
fun() is called 10 times 
fun() is called 11 times 
second call 
fun() is called 12 times 
third call 
fun() is called 13 times 

Jak widać wykorzystanie zmienne statyczne mogą doprowadzić do strasznych błędów.

Oto jedna funkcja , która spowoduje, że poczujesz wielki ból w przyszłości.

Ponadto użycie zmiennych statycznych spowodować nieczytelnym kodem, który jest podatny na błędy

Tylko nie rób tego!

Rozwiązanie 1: Zmienny przekazywane przez wartość

Rozważmy następujący kod:

#include <iostream> 
using namespace std; 

void fun(int i){ 
    cout<<i<<endl; 
    if(i!=3) { 
     i++; 
     fun(i); 
     fun(i); 
    } 
} 

int main(){ 
    fun(0); 
} 

To wyjście:

0 
1 
2 
3 
3 
2 
3 
3 
1 
2 
3 
3 
2 
3 
3 

Jak widać wyjście nie jest liczba razy ta funkcja nazywa się

Rozwiązanie 2: Zmienna przekazywane przez referencję

#include <iostream> 
using namespace std; 

void fun(int& x){ 
    if(x>=10) 
     return; 
    ++x; 
    cout << x << endl; 
    fun(x); 
} 

void funEntry(){ 
    int x = 0; 
    cout << "Entry point" << endl; 
    fun(x); 
} 

int main(){ 
    funEntry(); 
    funEntry(); 
} 

wypisze

Entry point 
1 
2 
3 
4 
5 
6 
7 
8 
9 
10 

Podejście to będzie działać również z jakimś bardziej egzotycznych rekurencyjnego wzoru jak ten

#include <iostream> 
using namespace std; 

void fun(int i, int& x){ 
    if(i>=4) 
     return; 
    ++x; 
    cout << i << " " << x << endl; 
    fun(i+1,x); 
    fun(i+2,x); 
} 

void funEntry(){ 
    int x = 0; 
    cout << "Entry point" << endl; 
    fun(0,x); 
} 

int main(){ 
    funEntry(); 
    funEntry(); 
} 

Wyjście:

Entry point 
0 1 
1 2 
2 3 
3 4 
3 5 
2 6 
3 7 
Entry point 
0 1 
1 2 
2 3 
3 4 
3 5 
2 6 
3 7 

Answer 2

użyj zmiennej statycznej wewnątrz funkcji rekursywnej. static int i = 0; i na początku funkcji, powiedz i ++.

za każdym razem, gdy funkcja zostanie wywołana, wartość ta zostanie zwiększona. a jeśli wartość i wynosi 10, możesz zakończyć.

Answer 3

jeśli trzeba zrobić to rekurencyjny ...

void fun(int i){ 

    cout<<hi; 
    if(i!=10) { 
     i++; 
     fun(i); 
    } 
} 

int main(){ 

    fun(0); 
} 

nadzieję, że pomoże?

Answer 4

Dodaj zmienną static jako licznik.

#include<iostream> 
using namespace std; 

void fun() 
{ 
    static int count=1; 
    count++; 
    cout << "fun() is called " << count << " times" << endl; 
    if(count<=10) 
    { 
      fun(); 
    } 
} 

int main() 
{ 
    fun(); 
} 

static zmienne inicjowane są tylko raz, a wartość zostanie zachowana w całej wywołań funkcji. Zobacz ten link http://en.wikipedia.org/wiki/Static_variable

Answer 5

void fun(int& x){ 
    if(x>=10) 
     return; 
    ... Do something 
    ++x; 
    fun(x); 
} 

Należy użyć odwołania do zmiennej zewnętrznej

Jeśli przechodzą przez licznik wartości nie można zrobić wiele wywołań w tej samej funkcji