Eine wahrscheinlich ganz dumme Anfängerfrage



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

    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?


  • Mod

    matze917 schrieb:

    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?



  • matze917 schrieb:

    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.



  • Bei jedem Funktionsaufruf bekommst du eine neue Variable wert.
    Die Alten sind aber nicht überschrieben oder gelöscht, sondern sind in "ihrer" Funktion gültig.



  • durch "return wert" wird der Wert zurückgegeben.

    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 😞



  • matze917 schrieb:

    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.



  • ..ich hab mir das jetzt noch extra handschriftlich notiert..jeden einzelnen Schritt..

    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?



  • Du brauchst einen großen Zettel als Bildschirm und viele kleine für die Funktionen.

    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.



  • Das return sorgt dafür, dass der Funktionsaufruf den Wert nach dem return annimmt (beendet gleichzeitig den Funktionsaufruf, aber das ist hier nebensächlich).

    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



  • hmm

    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?



  • matze917 schrieb:

    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).



  • okay, dann halte ich mich damit nicht länger auf. Bin jetzt schon drei Aufgaben weiter und es läuft wieder fast einwandfrei.

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

    Kann hiermit geschlossen werden!


Anmelden zum Antworten