//1. Programm zu Funktionen/Return

#include <iostream>

using namespace std;

int ermitteln (int Schaden, int HP, int Rest, int Hits); //Prototyp

//Hauptprogramm
int main ()
{
    //Variablen
    int Schaden = 0;
    int HP = 0;
    int Hits = 0;
    int Rest;

    //funktionsaufruf
    Rest = ermitteln (Schaden, HP, Rest, Hits);

    //Dialog
    cout << "Ich brauche sofort einen Statusreport ueber meine HP!" << endl;
    cout << "Nicht verfuegbar~" << endl;
    cout << "Kannst du es ermitteln?" << endl;
    cout << "\nBitte erhaltene Hits eingeben: ";
    cin >> Hits;
    cout << endl;
    cout << "Nun bitte den Schaden der Hits eintippen: ";
    cin >> Schaden;
    cout << endl;
    cout << "... Was waren deine Start-HP: ";
    cin >> HP;
    cout << "Werte werden ermittelt~";
    cout << "Rest HP: " << Rest << endl;
    cout << "~Vorgang abgeschlossen~" << endl;

    system ("PAUSE"); 
    return(0);

}

int ermitteln (int Schaden, int HP, int Rest, int Hits)
{
    int Temp; 

    Temp = HP - Hits * Schaden;

    return Temp; //rückgabe des ergebnisses
}

Hoffe auf NETTE und hilfreiche antworten

Du darfst "ermitteln" erst aufrufen, wenn du die Eingaben gelesen hast.

thihihi, dankeschön, jetzt geht es
Wusste nicht dass man die Funktion erst zu einem gewissen Zeitpunkt aufrufen darf

Dein Programm läuft sequentiell. Eine Zeile nach der anderen wird abgearbeitet. Wenn du eine Funktion aufrufst und ihr Werte übergibst, arbeitet sie selbstverständlich mit diesen Werten. Nicht mit Werten, die du eventuell irgendwann später im Programm noch erzeugst. In deinem Fall übergibst du der Funktion ermitteln ausschließich Nullen. Und damit rechnet sie dann nun mal.

thihihi, dankeschön, jetzt geht es
Wusste nicht dass man die Funktion erst zu einem gewissen Zeitpunkt aufrufen darf

Welche Werte soll er denn für die Funktionsparameter annehemen?
Die Namen der Variablen sind Schall und Rauch.
Der Prototyp braucht die Namen noch nicht einmal:

int ermitteln (int, int, int, int); //Geht auch
// Nur dann weißt du nicht mehr wofür die Parameter stehen :-(

Da kannst du auch direkt Zahlenwerte einsetzten.

ja hatte halt gedacht dass das bei Funktionen übertragen anders ist... naja hinterher ist mal immer schlauer, aus Fehlern lernt man

NekoHiTsuna schrieb:

thihihi, dankeschön, jetzt geht es
Wusste nicht dass man die Funktion erst zu einem gewissen Zeitpunkt aufrufen darf

Welche Werte soll er denn für die Funktionsparameter annehemen?
Die Namen der Variablen sind Schall und Rauch.
Der Prototyp braucht die Namen noch nicht einmal:

int ermitteln (int, int, int, int); //Geht auch
// Nur dann weißt du nicht mehr wofür die Parameter stehen :-(

Da kannst du auch direkt Zahlenwerte einsetzten.

hmmm? meinst du also dass ich nach int gleich die zahl setzen könnte?
aber dann ist dass doch gar nicht für die variable definiert... oder? *verwirrt sei*

Rest = ermitteln (Schaden, HP, 0, Hits); // den 3. Parameter nutzt du in der Funktion eh nicht.

oder

Rest = ermitteln (100, 100000, 0, 2);

War schlecht formuliert

Nee, beim Funktionsaufruf kannst du Zahlenwerte einsetzen:
//z.B.

Rest = ermitteln (Schaden, HP, 0, Hits); // den 3. Parameter nutzt du in der Funktion eh nicht.

oder

Rest = ermitteln (100, 100000, 0, 2);

War schlecht formuliert

hm, ist mir noch ein klein wenig unklar (klingt für mich noch unlogisch)
aber trotzdem danke für deine antwort
ich werde dann mal mein buch weiterlesen, mal schauen was da jetzt noch alles zu diesem thema kommt

DirkB schrieb:

Nee, beim Funktionsaufruf kannst du Zahlenwerte einsetzen:
//z.B.

Rest = ermitteln (Schaden, HP, 0, Hits); // den 3. Parameter nutzt du in der Funktion eh nicht.

oder

Rest = ermitteln (100, 100000, 0, 2);

War schlecht formuliert

hm, ist mir noch ein klein wenig unklar (klingt für mich noch unlogisch)
aber trotzdem danke für deine antwort
ich werde dann mal mein buch weiterlesen, mal schauen was da jetzt noch alles zu diesem thema kommt

jetzt verstehe ich was du meinst nachdem ich weitergelesen habe
... es wird dann erklärt dass es genügt den datentyp reinzuschreiben aber die reihenfolge sollte man einhalten (die reihenfolge der datentypen vor dem aufrufen der funktion)deswegen ist es übersichtlicher dann noch einen name dazuzuschreiben, aber nötig ist es nicht

wenn ich das so richtig verstanden habe

mal was anderes nebenbei: habe gerade ein beispiel gehabt wo es um Stack geht...
naja schaut auch am besten mal das programm an, dann wisst ihr was ich meine, ich verstehe halt nicht wieso es gleich bleibt:

//Funktion intern: Der Stack
#include <iostream>

using namespace std;

void erhoehePunkte (int Punkte);

//Hauptprogramm
int main ()
{
    //Variablen
    int Punkte = 1000;  //Punkte

    cout << "Punkte vor Funktionsaufruf :" << Punkte << endl;

    erhoehePunkte (Punkte);

    cout << "Punkte nach Funktionsaufruf: " << Punkte << endl;
    system ("PAUSE");
    return 0;
}
//erhoehe Punkte
void erhoehePunkte (int Punkte)
{
     Punkte+=100;
}

Kennst du Funktionen aus dem Mathe-Unterricht? So f(x)=y und so? Unsere Funktionen sind gar nicht unähnlich. Die wollen irgendwelche Werte übergeben bekommen (x) und spucken dafür einen Rückgabewert aus (y). Woher der Übergabewert x kommt, ist egal. Ob du jetzt direkt eine 3 übergibst, oder ob du eine Variable übergibst, die den Wert 3 hat, kommt für die Funktion aufs Gleiche raus.

Naja, die andere Auffassung ist im Matheunterricht aber auch nicht unverbreitet. Es geht hier um den Unterschied zwischen strict evaluation und non-strict evaluation. Beides sind berechtige Ansichten zum Nutzen von Funktionen und beides findet man sowohl im Alltagsgebrauch als auch in verschiedenen Programmiersprachen. C++ nutzt strict evaluation, der Threadersteller geht von lazy evaluation aus. Das geht natürlich nicht gut.

Ein typisches Beispiel für eine Sprache mit lazy evaluation ist der C-Präprozessor:

#define X 1
#define Y 2

#define foo X + Y

#undef X
#undef Y
#define X 4
#define Y 6

foo   // 4 + 6

edit: Zumindest die Ursprungfrage hatte dieses Problem. Weiteres Lesen des Threads lässt mich vermuten, dass da noch mehr falsche Vorstellungen sind.

Vergleich: Du hast zwei Mülleimer. Einen in der Küche und einen im Keller. Wenn du etwas in den Mülleiner in der Küche reinwirfst, verändert sich der Mülleimer im Keller nicht.

Das Zauberwort heißt hier "Call-by-value" vs. "Call-by-reference". Danach kannst du ja mal googlen...

*jumping out the basement-window*

edit: sehe gerade bei http://blog.gungfu.de/archives/2005/07/05/der-unterschied-zwischen-call-by-value-und-call-by-reference/ dass dort steht dass eine kopie übertragen wird aber x nicht verändert wird. also Punkte=Punkte*100, "die veränderung ist nicht sichtbar innerhalb einer methode" so stand es da ca.. und Punkte bleibt? oder wie ist das zu verstehen... ~bei int & punkte ist es ja sichtbar~ (seid geduldig mit mir, ich brauche immer meine zeit bis ich was verstehe )

wann kommen diese 2 varianten denn zum einsatz?

Na ja, call-by-value ist quasi der Standard. call-by-reference nimmst du immer dann, wenn du einen Grund dazu hast. Beispiel: du willst eine Funktion schreiben, die die Werte zweier int-Variablen vertauscht. Hier bietet sich call-by-reference an:

void swap(int& a, int& b) {
  int temp=a;
  a=b;
  b=temp;
}

Zum lazy-Evaluation: Haskell ist auch ein typisches Beispiel. Streng genommen benutzt der Präprozessor nicht lazy-Evaluation, weil das ist definiert durch leftmost-outermost-Graphreduction, und letzteres ist dabei nicht erfüllt

Na ja, call-by-value ist quasi der Standard.

Bei den eingebauten Datentypen vielleicht. Größere Objekte sollen standardmäßig als const Referenz übergeben werden.

naja, erstmal vielen dank für die ganzen antworten