long fakul( long n );

int main()
{
	long val;
    val = fakul( 6 );
	cout << "Fakultät aus 6 ist " << val << '\n';
	val = fakul( 10 );
	cout << "Fakultät aus 10 ist " << val << '\n';
	cin.get();
	return 0;
}

long fakul( long n )
{
	if( n )
	{
		return n * fakul( n - 1 );
	} 
	return 1;
}

Dann verstehe ich das return nicht: wie geschiet da die berechnung der fakultät...

Stimmt ich habe mich doof ausgedrückt.
Die Funktion erkennt der Compiler anhand der Parameter das weiss ich, nun gut, dann kann man also if( parameter ) abfragen dann sucht der Compiler nach der Funktion in der, der Parameter n vorkommt oder ?

Dann verstehe ich das return nicht: wie geschiet da die berechnung der fakultät...

Wie kannst du Rekursion verstanden haben, wenn du Funktionen noch nicht verstanden hast?

long fakul( int n )
{
int x = n;
while( --x )
{ 
   n *= x;
}
return n;
}

Ich habe Funktionen verstanden war nur etwas verwirrt da ich die Funktion zur Fakultät nicht verstanden habe ich habe herumprobiert und es mit einer Iteration probiert wobei es viel einfacher und verständlicher ist:

long fakul( int n )
{
int x = n;
while( --x )
{ 
   n *= x;
}
return n;
}

"viel einfacher und verständlicher" ist Ansichtssache. Aber deine Aussage "dann sucht der Compiler nach der Funktion in der, der Parameter n vorkommt oder ? " zeigt mir z.B., dass du Funktionen wohl doch nicht verstanden hast.
EDIT: Vielleicht bist du ja auch durch den Überladungs-Thread etwas durcheinandergekommen.

informiere dich mal über "Abbruchbedingung".
Dann solltest du auch die Fakultät verstehen (sowie die Rekursion an sich, denn bisher scheinst du sie doch nicht komplett verstanden zu haben

Vllt. hilft dir ja der Wiki-Beitrag http://de.wikipedia.org/wiki/Rekursive_Programmierung

"viel einfacher und verständlicher" ist Ansichtssache. Aber deine Aussage "dann sucht der Compiler nach der Funktion in der, der Parameter n vorkommt oder ? " zeigt mir z.B., dass du Funktionen wohl doch nicht verstanden hast.
EDIT: Vielleicht bist du ja auch durch den Überladungs-Thread etwas durcheinandergekommen.

Ja das kann gut sein das ich da durcheinander gekommen bin
Aber es stimmt doch oder ? habe ich es doch nicht verstanden ..

Informier dich mal über "Abbruchbedingung".

Werde ich machen, ich sag falls ich noch Fragen habe ( wenns ok ist ) danke
Jetzt merk ich so nebenbei Abbruchbedingungen kenne ich doch lange aus Iterationen while () ...

Ich glaub ich bin einfach Dumm

Aber es stimmt doch oder ? habe ich es doch nicht verstanden ..

Ich sehe einfach keinen Sinn in diesem Satz.

hab langsam das Gefühl ich habe es nicht verstanden ich wiederhole morgen nochmal die Funktionen und Rekursionen!

wenn ich ne funktion hätte int funktion( par1, par2 );

Da fehlen die Typen von par1 und par2.

könnte ich dann so prüfen : ?
if ( par1 || par2 )
{
}

Hängt davon ab, was par1 und par2 sind. Wenn's beides booleans sind kannst Du so prüfen, ob mindestens einer davon true ist. Aber ich hab das Gefühl, das ist nicht, was Du meintest?

Überladung und Rekursion sind zwei völlig verschiedene Themen.

Aber fangen wir mal vorne an:

In C++ gibt es Funktionen. Diese sind gekennzeichnet durch einen Rückgabetyp, einem Namen für die Funktion und einer Liste von Parametern. Des weiteren haben Funktionen einen Funktionsrumpf, der die Funktion beschreibt.

Funktionen können "aufgerufen" werden, d. h. es wird zur Laufzeit an jeden Parameter ein Wert gebunden und mit diesen konkreten Werten alle Befehle des Funktionsrumpfes ausgeführt.

Eine Funktion heißt rekursiv, wenn in ihrem Funktionsrumpf ein Aufruf der Funktion selbst erfolgt. (In einem Duden würde ich Rekursion durch "Siehe Rekursion" erklären )

Nun zu der Funktion fakul.

long fakul( long n ) 
{ 
    if( n ) 
    { 
        return n * fakul( n - 1 ); 
    } 
    return 1; 
}

Nach dieser Definition ist Fakul eine Funktion die einen long int als einzigen Parameter annimmt und einen long int zurück gibt.

Erfolgt nun ein Aufruf dieser Funktion mit z.B. dem Parameter 5, dann ist das erwartete Ergebnis 5! = 5*4*3*2*1 = 120. Bei dem Aufruf wird also die 5 an das n gebunden. An jeder Stelle, wo n vorkommt kann ich mir also für diesen Aufruf von fakul auch eine 5 denken!
Die if prüft nun, ob n wahr ist, d.h. ob n != 0 ist. Da n an 5 gebunden ist und 5 != 0 gilt, wird also in die If gegangen.

In dieser If steht nun als einzige Anweisung, das sich die Rückgabe der Funktion berechnet aus n * fakul(-n1), also von 5 * fakul(5-1), also 5 *fakul(4). Wir müssen also zunächst das Ergebnis von fakul(4) wissen, bevor wir das Ergebnis von fakul(5) berechnen können.

Es erfolgt also ein Aufruf von fakul mit dem Parameter 4. An n wird nun für diesen Aufruf der Wert 4 gebunden. Abermals erfolgt der in der If die Überprüfung, ob n != 0 ist, also ob 4 != 0 ist, was wahr ist. Es geht also wieder in die If hinein. In dieser If ist nur eine Anweisung, nämlich, das Ergbenis berechnet sich als 4*fakul(3).

Dies wird sich jetzt fortsetzen, bis fakul mit einem Wert für den Paramter n aufgerufen wird, der nicht in die If geht. Dies löst die Abruchbedingung aus und die Rekursion endet.

Du kannst ja mal von fakul(3) ausgehend dies dir überlegen.

Hoffe das bringt etwas Licht ins Dunkel

[...] dann kann man also if( parameter ) abfragen dann sucht der Compiler nach der Funktion in der, der Parameter n vorkommt oder ?

In diesem Kontext, der Parameter ist von einem Ganzzahltyp, ist "if (n)" äquivalent zu "if (n!=0)". Der int-Wert wird (explizit) zu bool konvertiert, weil die if-Bedingung ein boolscher Kontext ist. Bei int: Aus 0 wird false und aus allem anderen wird true. Deswegen hast Du denselben Effekt, wenn Du statt (n) hier (n!=0) schreibst. Du hast hier also eine einfache Fallunterscheidung. Das ist die Abbruchbedingung der Rekursion, oder genauer: Das Negativ der Abbruchbedingung. So lange n!=0, wird sich die Funktion selbst mit einem neuen n aufrufen. Falls n==0 ist, kann direkt 1 zurückgegeben werden, da 0! = 1.

hab langsam das Gefühl ich habe es nicht verstanden ich wiederhole morgen nochmal die Funktionen und Rekursionen!

Kurz erklärt:

Funktion --> eine evtl. häufig benötigte Programmleistung mit einer Syntax wie hier long = facul(long n); Es wird ein Parameter der Funktion übergeben, die macht damit etwas und gibt mit return etwas zurück.
Rekursion --> Die Funktion hier ruft innerhalb der Funktion sich selbst auf.
Abbruchkriterium --> Ist in jeder rekursiven Funktion etwas tricky. Dies ist ein einfaches Beispiel zum Üben und Verstehen. Füge vor jedes return eine Kontrollausgabe für n ein und auch eine Kontrollausgabe, wo die rekursive Funktion aufgerufen wird. Oder nehme einen Debugger dafür.
Noch unsicher --> Wie selbst erkannt, vorläufig mit while arbeiten.

@ andere Poster: Haut dem Fragesteller das bitte nicht gleich um die Ohren!