Verfolgen Sie, wie oft eine rekursive Funktion in C++ aufgerufen wurde

Question

Ich versuche, an einem Programm zu arbeiten, das eine Funktion hat, deren Parameter ein Vektor von String ist. Ich möchte auf diese Funktion rekursiv verwenden, aber jedes Mal die Funktion aufgerufen wird, möchte ich

dhzB den Parameter ändern

fun(stringArray[i]) 

, wo ich die Anzahl der Zeit ist die Funktion aufgerufen wurde.

Also in einfacher Weise etwas wie folgt. Aber ich muss im Auge behalten, wie oft der Funktionsspaß ausgeführt wurde.

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

int main(){ 

    fun(); 
} 

In diesem sagen wir, ich es nur 10-mal ausdrucken möchten aus, so wollen eine varible haben, erhöht, und wenn 10 erreicht, stoppt er. Was kann ich im Allgemeinen tun, um den Überblick zu behalten? Ich habe versucht, globale Variablen zu verwenden, aber sie scheinen nicht mit Funktionen zu arbeiten. Irgendwelche Vorschläge?

Answer 1

ich gesehen habe machen können Es war ziemlich durcheinander, also beschloss ich, die Dinge zu klären.

Lösung 0: Statische Variable

den Code Betrachten wir mit einer leichten Modifikation vorgeschlagen

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

Und dies ist die Ausgabe:

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 

Wie Sie die Verwendung von sehen statische Variablen könnten zu einigen schrecklichen Fehlern führen.

Hier haben Sie eine One-Shot-Funktion, die Ihnen einige große Schmerzen in der Zukunft verursachen wird.

Des Weiteren führt die Verwendung von statischen Variablen zu einem nicht lesbaren Code, die fehleranfällig

Nur nicht tut es!

Lösung 1: Variable Wert übergeben

diesen Code vor:

#include <iostream> 
using namespace std; 

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

int main(){ 
    fun(0); 
} 

Dies ist die Ausgabe:

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

Wie Sie die Ausgabe nicht das ist zu sehen wie oft die Funktion aufgerufen wird

Lösung 2: Variable per Referenz übergeben

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

wird wie dieser

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

Output Dieser Ansatz funktioniert auch mit etwas exotischere rekursive Muster

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

drucken:

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

Verwenden Sie die statische Variable innerhalb der rekursiven Funktion. statisch int i = 0; und am Anfang der Funktion, sagen wir i ++.

Jedes Mal, wenn die Funktion aufgerufen wird, wird dies inkrementiert. und wenn der Wert von i 10 wird, können Sie terminieren.

Answer 3

, wenn Sie es rekursive ...

machen müssen

void fun(int i){ 

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

int main(){ 

    fun(0); 
} 

Hoffnung, das hilft?

Answer 4

Fügen Sie eine static Variable als Zähler hinzu.

#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 Variablen werden nur einmal initialisiert und der Wert wird über Funktionsaufrufe beibehalten werden. Siehe diesen Link http://en.wikipedia.org/wiki/Static_variable

Answer 5

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

Sie sollten einen Verweis auf eine externe Variable

Wenn Sie die Zähler nach Wert übergeben Sie nicht mehrere Anrufe in der gleichen Funktion