recur

02/26/2013 17:23 ExHack#1
hallo
Code:
#include <iostream>
void countdown(int n);

int main()
{
    countdown(4);           
    
    return 0;
}

void countdown(int n)
{
    using namespace std;
    cout << "Counting down ... " << n << endl;
    if (n > 0)
        countdown(n-1);    
    cout << n << ": Kaboom!\n";
}
____________________________________________
Kommt raus:
Counting down ...4
Counting down ...3
Counting down ...2
Counting down ...1
Counting down ...0
0: Kaboom!
1: Kaboom!
2: Kaboom!
3: Kaboom!
4: Kaboom!
Was passiert nach "0: Kaboom! " bis da verstehe ich alles ,wie kommt es aber zu "1: Kaboom! " ?
02/26/2013 17:35 Dr. Coxxy#2
na, rekursion halt.

du rufst countdown mit 4 auf, das gibt er aus, n ist noch > 0, also ruft er wieder countdown mit 3 auf ("Kaboom!" wurde noch nicht ausgegeben! ist immer noch in der funktion!), usw. bis er bei 0 landet, dann greift das if nicht, er gibt kaboom 0 aus, er springt zurück zum aufrufer (Kaboom 1), gibt kaboom 1 aus, springt zurück zum aufrufer (kaboom 2) usw...

Um das zu vermeiden müsstest du das kaboom cout in ein else schmeißen.
02/26/2013 17:58 ExHack#3
:confused: ...
Quote:
er springt zurück zum aufrufer (Kaboom 1)
aufrufer (Kaboom1)? wohin sprigt er ? zu countdown(n-1) ? was ruft (Kaboom1) auf ?
02/26/2013 18:08 Dr. Coxxy#4
ist etwas schwierig zu erklären ohne auf den stack und low level assembler einzugehen, zmdst für mich :P

du rufst countdown 4 auf, der gibt das aus und ruft countdown(4-1) auf.
die zeile die NACH dem aufruf kommen würde hat er aber in dem moment noch nicht ausgeführt, das heißt wenn countdown(4-1) fertig ist, führt er natürlich noch das cout n kaboom aus. n ist in diesem funktionsaufruf noch 4.
und so weiter, er speichert sozusagen die noch fehlende zeile und führt sie danach aus.

Ich schreib das ganze eben mal in inline code aus, dann ists vllt was verständlicher.

moment:

EDIT:

Code:
	// aus countdown(4); wird im endeffekt:

	int n = 4;
	cout << "Counting down ... " << n << endl;
	if (n > 0)
	{
		int n = 3;
		cout << "Counting down ... " << n << endl;
		if (n > 0)
		{
			int n = 2;
			cout << "Counting down ... " << n << endl;
			if (n > 0)
			{
				int n = 1;
				cout << "Counting down ... " << n << endl;
				if (n > 0)
				{
					int n = 0;
					cout << "Counting down ... " << n << endl;
					if (n > 0)
					{
						// NEVER REACHED!
					}
					cout << n << ": Kaboom!\n";
				}
				cout << n << ": Kaboom!\n";
			}
			cout << n << ": Kaboom!\n";
		}
		cout << n << ": Kaboom!\n";
	}
	cout << n << ": Kaboom!\n";
Im endeffekt passiert das hier, jetzt etwas klarer?

Jeder block hat eine eigene lokale variable n, deswegen hat das verringern innerhalbs keine auswirkungen auf die äußeren.
02/26/2013 18:14 Schlüsselbein#5
Du musst dir genau darüber im klaren sein, was passiert, wenn du eine Funktion aufrufst. Nungut, nicht ganz, aber du solltest folgendes wissen:
Wenn eine Funktion aufgerufen wird, springt man quasi "hinein", führt den Code in der Funktion aus und sprint zum Caller zurück.
Zeichne es dir auf oder so, aber da musst du schon selber dahinter steigen.

Und um für noch ein wenig mehr Verwirrtheit zu sorgen:
Code:
#include <iostream>

template <unsigned int N>
void count()
{
	count<N - 1>();
	std::cout << N << std::endl;
}

template <>
void count<0>()
{
	std::cout << 0 << std::endl;
}

int main()
{
	count<100>();
}
:D
02/26/2013 18:29 yihaaa#6
Code:
void countdown( int n )
{
	if ( n >= 0 )
	{
		std::cout << n << std::endl;
		countdown( n - 1 );
	}
}
02/26/2013 18:36 Dr. Coxxy#7
Quote:
Originally Posted by Schlüsselbein View Post
Code:
#include <iostream>

template <unsigned int N>
void count()
{
	count<N - 1>();
	std::cout << N << std::endl;
}

template <>
void count<0>()
{
	std::cout << 0 << std::endl;
}

int main()
{
	count<100>();
}
was sollen die templates?
02/26/2013 18:38 Schlüsselbein#8
Quote:
was sollen die templates?
Ich sagte ja: Verwirrung :p

Schau dir templates und template specialization an und du wirst sehen, wo der Unterschied darin liegt.
02/26/2013 18:42 yihaaa#9
Nj man kanns auch missbrauchen.
Cheers!
02/26/2013 18:43 Dr. Coxxy#10
Quote:
Originally Posted by Schlüsselbein View Post
Ich sagte ja: Verwirrung :p

Schau dir templates und template specialization an und du wirst sehen, wo der Unterschied darin liegt.
ich weiß, wie es funktioniert, es ist aber vollkommen unnötig dafür vom compiler 100 extra funktionen erstellen zu lassen - ergo vollkommen unnötig und am thema vorbei.

genauso wie die posts von yihaaa...
02/26/2013 18:44 Schlüsselbein#11
Quote:
ich weiß, wie es funktioniert, es ist aber vollkommen unnötig dafür vom compiler 100 extra funktionen erstellen zu lassen - ergo vollkommen unnötig und am thema vorbei.
Dass du heut wohl kein Fick beckommen hast, dafür kann ich nichts. Warum so stinkig? Es gab auch von mir ne korrekte Antwort an den TS und als Schmankerl und aus Spaß(!) gabs halt noch das kleine Extra.
Wenn du weißt, was die Templates da sollen, wozu dann die Frage?
In der Tat ist das mMn das einfachste Beispiel, um jemandem template recursion näher zu bringen.

Quote:
Nj man kanns auch missbrauchen.
Cheers!
Nö, gibt auch Anwendungsfälle dafür: Template metaprogramming - Wikipedia, the free encyclopedia
02/26/2013 18:46 yihaaa#12
Ja damit hätte ich auch gerechnet, dass es Anwendungsfälle dafür gibt. Aber du hast dir nur eine schlechten hier rausgesucht :P
02/26/2013 20:55 MrSm!th#13
Am besten holen wir Shadow dazu, der wird uns dann erklären, dass die Template-Version minimal schneller ist, weil der Vergleich wegfällt :p