Ich sitze nun seit einer Stunde an der Aufgabe und komme kein Stück weiter
Habe im Internet nach Funktionsprototp geguckt, auch im Forum die Suche benutzt, aber richtig weiterhelfen konnte mir kein Ergebnis..
Und das Script von unserem Prof kann man erst recht in die Tonne kloppen

Also hier erst einmal das Programm:

#include <iostream>
using namespace std;

int tuwas(int wert);

int main(void)
{
    cout<<"Ereignis: "<<tuwas(2)<<endl;

    system("Pause");
    return 0;       
}

int tuwas(int wert)
{
    wert=wert+1;
    cout<<wert<<",";
    if(wert<=5)
    {
                    wert=wert+tuwas(wert);
    }

    return wert;
}

Die simple Frage..was kommt hinten raus?

Das Ergebnis lautet: 3,4,5,6, Ereignis: 18

Aber ich verstehe einfach nicht, wie man auf die Ausgabe kommt. Bis zur 3 bin ich noch dabei, aber danach bin ich verloren.

Ich wäre echt dankbar, wenn mir jemand einmal genau erklären was mit der 3 im "If-Bereich" geschieht.

Danke schon einmal im Vorraus!

Ich wäre echt dankbar, wenn mir jemand einmal genau erklären was mit der 3 im "If-Bereich" geschieht.

Aus der 3 wird 3+tuwas(3), musst du ja nur ablesen.
Was tuwas(3) ergibt, musst du halt wieder auf die gleiche Art berechnen.

Ich sitze nun seit einer Stunde an der Aufgabe und komme kein Stück weiter
Habe im Internet nach Funktionsprototp geguckt, auch im Forum die Suche benutzt, aber richtig weiterhelfen konnte mir kein Ergebnis..

Das ist auch irgendwie nicht der richtige Suchbegriff. Du suchst Rekursion.

(Funktionsprototypen sind eine spezielle (wenn auch die übliche) Form der Funktionsdeklaration in C, in C++ heißen die einfach Deklarationen.)

Aber ich verstehe einfach nicht, wie man auf die Ausgabe kommt. Bis zur 3 bin ich noch dabei, aber danach bin ich verloren.

Dann überleg dir doch erstmal, was für 5 rauskommt. Mal als Übung: Was kommt für 5, 4, 3, 2 raus? In der Reihenfolge. Und selber denken, nicht ausprobieren.

Ich wäre echt dankbar, wenn mir jemand einmal genau erklären was mit der 3 im "If-Bereich" geschieht.

Nichts besonderes eigentlich. Es steht alles da, du musst nur beim Selbstaufruf keinen Knoten im Gehirn bekommen...

Noch kurz zum Thema Funktionsprototyp: mein Prof hat das bei der Aufgabe extra dazugeschrieben, von daher bin ich auch davon ausgegangen, dass es sich um einen solchen handelt.

Also, einmal ganz ausführlich und langsam:

ich beginne mit der 2, die in die tuwas-Funktion eingesetzt wird.

wert= 2+1

Damit hätte wir dann schon einmal die 3 in der Ausgabe. Weiter geht's.

wert=3+tuwas(3)

Und jetzt springe ich nach wieder nach oben, um den tuwas-Wert von 3 herauszufinden.

wert= 3+1

Damit hätte ich dann die 4 in der Ausgabe.

..so geht das dann weiter bis zur 5.

wert= 5+1

Damit habe ich dann die 6 in der Ausgabe stehen und da 6 > 5, fällt der if-Teil schon einmal flach.

Jetzt fehlt mir nur noch der Weg zur "goldenen" 18..ist halt die Summe aller bisherigen Zahlen, aber wo steht da der Befehl zur Addition?

Jetzt fehlt mir nur noch der Weg zur "goldenen" 18..ist halt die Summe aller bisherigen Zahlen, aber wo steht da der Befehl zur Addition?

Die Funktionen sind an der Stelle auch noch nicht zu Ende. Was gibt tuwas(5) zurück? Wohin kehrt tuwas(5) zurück? Was passiert dort mit dem Rückgabewert?

Danke schon einmal für die fixen Antworten, fühlt euch dick gelobt!

Du musst sie aber auch lesen

Noch kurz zum Thema Funktionsprototyp: mein Prof hat das bei der Aufgabe extra dazugeschrieben, von daher bin ich auch davon ausgegangen, dass es sich um einen solchen handelt.

Er meint das hier:

int tuwas(int wert);

Das hilft dir aber nicht, zu verstehen, wie die Funktion arbeitet, das ist nur die Deklaration, damit der Compiler in main schon weiß, wie er die Funktion aufrufen soll.

Ich steig da einfach nicht richtig durch. In einem Forum stand, dass die eine Funktion die Werte an die Hauptfunktion übergibt. Aber wie und wohin..ich versuche das ja selbst zu verstehen und nachzuvollziehen, aber ich komme da nicht weiter

In einem Forum stand, dass die eine Funktion die Werte an die Hauptfunktion übergibt.

Nein, der Wert wird an die aufrufende Funktion zurückgegeben.
Beim ersten Aufruf von tuwas(2) ist das die "Hauptfunktion" main(), aber bei allen weiteren Aufrufen wird der Wert an tuwas zurückgegeben.

tuwas(2) gibt 2+1+tuwas(3) zurück, tuwas(3) gibt 3+1+tuwas(4) zurück usw.
Musst halt solange weiter machen, bis du alle noch unbekannten Funktionswerte kennst und dann kommst du letztendlich darauf, dass 2+1+tuwas(3) 18 ergibt.

tuwas (2)
wert=2+1
=> 3
wert=3+tuwas(3)

tuwas (3)
wert=3+1
=> 4

..und so weiter bis zur 5

tuwas (5)
wert=5+1
=> 6

return wert

Wo steht da jetzt der Befehl zur Addition?
Was genau sagt das "return wert" aus?

Nimm dir für jeden Funktionsaufruf einen neuen (kleinen) Zettel.
Pack den auf den vorhandenen drauf.
Rechne die Funktion durch (wenn da tuwas steht, dann neuen Zettel)
Wenn da cout steht, schreibst du das auf deinen Bildschirm

Wenn du beim return ankommst nimmst du den Wert von wert, merkst ihn dir, nimmst den obersten Zettel weg und schreibst den Wert (auf dem jetzt obersten Zettel) dort hin, wo du vorher aufgehört hast.( Das ist da wo tuwas steht). Und rechnest auf diesem Zettel weiter.

tuwas(2) in der main() steht für eine Zahl, genau wie cos(0) in der Mathematik für eine Zahl steht. Weil der Compiler noch nicht weiß, welche Zahl das ist, führt er tuwas(2) aus. Das erste return in der Funktion bestimmt diese Zahl.

Wichtig ist, dass all diese Funktionsaufrufe unabhängig voneinander sind (in dem Sinne, dass jeder seine eigene "wert"-Variable hat).

Also nochmal: main() ruft tuwas(2) auf.
Der Wert davon ist 2+1+tuwas(3).
Wir wissen nicht, was tuwas(3) ist, also müssen wir das auch erst ausrechenen:
tuwas(3) ist 3+1+tuwas(4)
tuwas(4) ist 4+1+tuwas(5)
In tuwas(5) greift nun die if-Bedingung nicht mehr, also gibt tuwas(5) 6 zurück.
Damit können wir nun den Wert von tuwas(4) bestimmen, nämlich 4+1+6=11.
Dann auch von tuwas(3): 3+1+11=15
Und tuwas(2): 2+1+15=18

also danke an Dirk für die Idee mit den Zetteln, hab ich gerade mit Post-it's gemacht und bin auch darauf gekommen. Hatte ganz zum Anfang auch diesen Weg im Sinn. Hatte dann aber gedacht, dass der Kompiler sicherlich nicht noch einmal rückwärts rechnet..aber anscheinend ja schon^^

Hatte mir jetzt aber irgendwie "mehr" von der Aufgabe selbst erwartet..

Frage b) ist, wie der Fachbegriff für die Art des Funktionsaufrufes ist. Die richtige Antwort wäre dann "Rekursion"?

Ich danke allen Beteiligten für ihre Geduld, aus anderen Foren ist man da anderes gewohnt..

und noch eine letzte Frage:

Warum wird "Ergebnis" nicht zuerst ausgegeben? Schließlich steht es doch vor tuwas(2) in main?

Warum wird "Ergebnis" nicht zuerst ausgegeben? Schließlich steht es doch vor tuwas(2) in main?

Die Frage ist berechtigt, aber ich hoffe nicht, dass der Professor erwartet, dass ihr das im Detail erklären könnt.
Letztendlich läuft es darauf hinaus, dass die Sprache dem Compiler freistellt, in welcher Reihenfolge er die Parameter eines Funktionsaufruf auswertet.
Je nachdem, ob er tuwas(2) zuerst auswertet oder nicht, wird entweder 3,4,5,6, Ereignis: 18 oder Ereignis: 3,4,5,6,18 ausgegeben.

Und ja, die Kette von << sind letztendlich verschachtelte Funktionsaufrufe von operator<<, auch wenn es nicht so aussieht.

Aber das ist eher einer der Schattenseiten von C++, mit der man sich in der Praxis nur soweit auseinandersetzt, als dass man sie umgeht (indem man nicht mehrere Funktionsaufrufe mit Seiteneffekten in den gleichen Ausdruck packt).

Danke für die ganzen Antworten, ihr seid eine super Hilfe!

Kann hiermit geschlossen werden!