Funktionen: Rückgabewert

Transkript

1 Funktionen: Rückgabewert Jede Funktion in C++ (außer Konstruktoren und Destruktoren siehe später) MUSS einen Rückgabewert-Typ vereinbaren. Gibt sie nichts zurück, muss der Rückgabetyp void sein. Jede return-anweisung sollte einen geeigneten Rückgabewert definieren. Entspricht er nicht dem Typ der Funktion, wird er in diesen umgewandelt (bzw. es ist ein Fehler, wenn das nicht möglich ist!). Die Typangabe auto als Rückgabetyp ist seit C++11 in Funktionsdefinitionen (nicht aber in Funktionsdeklarationen) erlaubt und seit C++14 vereinfacht nutzbar. Der Typ der Funktion wird in diesem Fall vom Compiler aus der (den) return-anweisung(en) bestimmt. double f() return 1.0; double f() return 1; auto f() return 1; // Achtung, es wird 1.0 zurückgegeben // seit C++14 in dieser Form in Funktionsdefinitionen erlaubt // f() ist dadurch vom Typ int, es wird 1 zurückgegeben Funktionen: Wert-Übergabe Funktionen können vom Aufrufer Werte erhalten, mit denen sie Berechnungen durchführen. Die Funktionsdefinition (oder deklaration) muss diese formalen Argumente vollständig definieren und bei allen Aufrufen müssen in den Klammern () entsprechende aktuelle Argumente angegeben sein. Sollte der Argument-Typ beim Aufrufer nicht dem Typ der Funktionsdefinition entsprechen, wird das Argument in diesen konvertiert. Ist das nicht möglich, ist das ein Fehler und das Programm wird nicht kompiliert: int f(int a, int b) return a+b;

2 Bei der Wertübergabe steht nur der Typ des Arguments ohne Ampersand & da. Werden Variable als Argument an eine Funktion per Wert übergeben, besitzen sie nach dem Funktionsaufruf immer noch den alten Wert, sie können also von der Funktion nie verändert werden (die Funktion erhält in Wahrheit nur eine Kopie des Originalarguments): void f(int x) x = 5; x = 1; f(x); cout << x; // druckt 1 (NICHT 5). Die Typangabe auto für Funktionsargumente ist nicht erlaubt! (Stand C++17) void f(auto x) // Fehler!! Was darf man per Wert übergeben (am Beispiel: int f(int);) Konstante: Variable int i; f(i); umwandelbare Variable char i; f(i); konstante Variable const int i; f(i); Rechenergebnisse f(i+3); f(i++); Was darf man nicht per Wert übergeben: nicht umwandelbare Variable string i; f(i); nicht umwandelbare Konstante oder Ausdrücke: f("text"); Objektinstanzen, die nicht kopiert werden können (z.b. cin, cout) Funktionen: lvalue-referenz-übergabe Statt der Wert-Übergabe kann die Funktion auch eine Referenz-Übergabe eines formalen Arguments vereinbaren (erkennbar am &-Zeichen zwischen Typangabe und Argumentname). Seit C++11 nennt man diese Art der Referenzen lvalue-referenzen (denn C++11 definiert zusätzlich rvalue-referenzen und universelle Referenzen, erkennbar am doppelten Ampersand &&):

3 void f(int& lv) lv = 5; // oder void f(int &lv) oder void f(int & lv) In diesem Fall kann die Funktion die übergebene Variable des Aufrufers ändern. Was darf man per lvalue-referenz übergeben (am Beispiel: int f(int&);) Variable vom richtigen Typ int i; f(i); Objektinstanzen, die nicht kopiert werden können (z.b. cin, cout) Was darf man nicht per lvalue-referenz übergeben: Konstante: konstante Variable const int i; f(i); umwandelbare Variable char i; f(i); nicht umwandelbare Variable string i; f(i); nicht umwandelbare Konstante oder Ausdrücke: f("text"); Rechenergebnisse f(i+3); f(i++); Die Übergabe einer Konstanten, einer konstanten Variablen, einer Variablen von einem anderen Typ (auch wenn es eine passende Typumwandlung gibt!) oder das Ergebnis eines Ausdrucks ist in diesem Fall ein Fehler: int x = 1; f(x); x hat danach den Wert 5. const int c = -1; f(c); // Fehler: Konstante Var. per lv.-referenz übergeben // Fehler: Konstante per lv.-referenz übergeben double y = 1.5; f(y); // Fehler: falscher Typ per lv-referenz übergeben f(x + 0); // Fehler: Rechenergebnis per lv-referenz übergeben f(abs(x)); // Fehler: Rechenergebnis per lv-referenz übergeben void f(int& x) x = 5; x = 1; f(x); cout << x; // druckt 5

4 Funktionen: const-lvalue Referenz-Übergabe Die Funktion kann auch eine konstante lvalue-referenz-übergabe (Schlüsselwort const) vereinbaren. Dann darf sie das Argument auf keinen Fall ändern, aber auch keine Funktion aufrufen, die das Argument ändern könnte. void g1(int x) // kann Original-Argument nicht ändern (Wertübergabe) // darf aber x ändern void g2(const int& x) // darf Argument x nicht ändern (const lv-referenz) void g3(int& x) // g3 kann und darf x ändern (lv-referenz) // ändert dadurch auch das Original-Argument void f(const int& x) // f darf x nicht ändern (const lv-referenz) x = 5; // Fehler: x darf nicht verändert werden g1(x); // korrekt: x kann von g1 nicht verändert werden g2(x); // korrekt: x darf von g2 nicht verändert werden g3(x); // Fehler: x könnte von g3 geändert werden Der Standard erlaubt die Benutzung des const nach der eigentlichen Typangabe: const int& a ist dasselbe wie int const& a Die meisten Programmierer schreiben aber const vor den Typ! Was darf man per Referenz übergeben (am Beispiel: alles Umwandelbare int f(int&);) int x = 1; f(x); const int c = -1; f(c); double y = 1.5; f(y); f(x + 0); f(abs(x)); Erklärung: Wird eine Variable per lvalue-referenz übergeben, muss diese im Speicher vorhanden sein und den richtigen Typ haben. Es müssen daher für Konstante (haben keinen Speicherplatz), Ergebnisse eines Ausdrucks und Argumente vom falschen Typ temporäre

5 Variablen benutzt werden, die nach dem Aufruf automatisch gelöscht werden. Der C++ Compiler erledigt alle diese Aufgaben automatisch! f(1) von oben erzeugt das Code-Stück: int tmp = 1; // Konstante im Speicher ablegen f(tmp); // Aufruf mit Referenz // Variable tmp wieder löschen f(y) von oben erzeugt das Code-Stück: int tmp = y; // im Speicher den konvertierten Wert ablegen f(tmp); In beiden Fällen wird also in Wirklichkeit eine temporäre Variable an die Funktion per lv- Referenz übergeben und nicht das Original. Die Funktion könnte daher das Original gar nicht ändern, da sie nur das temporäre Objekt erhält. So etwas erlaubt C++ in allen Versionen nur, wenn eine konstante lv-referenz übergeben wird, d.h. die Funktion verspricht, das Original ohnehin nicht zu ändern. Funktionen: rvalue-referenz-übergabe Diese Übergabemethode erkennt man an den 2 Ampersand, z.b.: int f(int&&); Eine rvalue-referenz kann sich immer nur auf einen rvalue, das ist eine Konstante oder eine temporäre Objektinstanz (z.b. Rechenergebnis) beziehen, aber nie auf eine von uns selbst definierte Variable (= lvalue) oder einen Teil davon! Was darf man per rvalue-referenz übergeben (am Beispiel: Konstante: umwandelbare Variable char i; f(i); Rechenergebnisse f(i+3); f(i++); int f(int&&);) Was darf man nicht per Wert übergeben: Variable int i; f(i); konstante Variable const int i; f(i); nicht umwandelbare Variable string i; f(i); nicht umwandelbare Konstante oder Ausdrücke: f("text"); int x = 1; f(x); const int c = -1; f(c); double y = 1.5; f(y); // Fehler: x ist ein lvalue // Fehler: c ist ein lvalue (und obendrein konstant) // korrekt: Konstante ist ein rvalue // korrekt: falscher Typ ist ein rvalue

6 f(x + 0); f(abs(x)); // korrekt: Rechenergebnis ist ein rvalue // korrekt: dieses Funktionsresultat ist ein rvalue Konstante rvalue-referenzen sind laut Standard zwar erlaubt, machen aber absolut keinen Sinn und werden daher nie verwendet! Funktionen: mehrere Argumente Natürlich kann eine Funktion mehr als 1 Argument definieren und für jedes einzelne von ihnen die Wert-, Referenz- (lvalue oder rvalue) oder const-refererenz vereinbaren. Bei jedem Aufruf müssen entsprechend viele Argumente angegeben sein! void addiere(double a, const double& b, double& summe) summe = a + b; double x; addiere(1, 2, x); // korrekt: x hat jetzt den Wert wird in 1.0 umgewandelt und per Wert übergeben 2 wird in 2.0 umgewandelt, temporär gespeichert und als konstante lv-referenz übergeben x wird per lv-referenz übergeben und dient hier eigentlich als Rückgabewert der Summe Auf diese Weise lassen sich von einer Funktion mehrere Resultate zurückgeben: Eines (oder keines) davon als Rückgabewert und die restlichen mittels lv-referenz-argumenten! Funktionen: Default-Argumente Eine Funktion kann (nur bei ihrer erstmaligen Deklaration oder Definition) optional Default- Werte für einige oder alle Argumente definieren. Diese dürfen dann beim Aufruf als aktuelle Argumente fehlen und werden in diesem Fall durch die Default-Werte ersetzt: double addiere(double a, double b = 1.0, double c = 3.0) return a + b + c;

7 f(-1.0, 2,0, 7.0); // korrekt: Rückgabewert ist 8.0 ( ) f(-1.0, 2.0); // korrekt: Rückgabewert ist 5.0 ( ) f(-1.0); // korrekt: Rückgabewert ist 3.0 ( ) f(); // Fehler: Argument a fehlt Selbstverständlich können auch alle Argumente einen Default-Wert bekommen. Defaultwerte können aus naheliegenden Gründen nur für die letzten Argumente vergeben werden, d.h. die folgende Definition wäre nicht erlaubt (hat ein Argument einen Default- Wert, müssen auch alle danach folgenden einen Default-Wert besitzen)! double addiere(double a = -1.0, double b) // Fehler!! return a + b; Prinzipiell darf man auch Funktionen mit Default-Argumenten überladen, es darf nur kein Aufruf dieser Funktionen mehrdeutig sein: int f(int a, int b) return a+b; double f(int a, int b = 1, double x = 0.0) return a+b+x; // 2 Argumente // 3 Argumente, also ok auto x = f(1, 2, 3); // ok, ruft Variante 2 auf: f(1, 2, 3.0) auto y = // ok, ruft Variante 2 auf: f(1, 1, 3.0) auto z = f(1, 2); // Fehler, das ist mehrdeutig