Referenztypen

Question 1

Betrachte folgenden Code:

𝚟𝚘𝚒𝚍 𝚜𝚠𝚊𝚙(𝚒𝚗𝚝 𝚡, 𝚒𝚗𝚝 𝚢) {
  𝚒𝚗𝚝 𝚝 = 𝚡; 
  𝚡 = 𝚢; 
  𝚢 = 𝚝; 
}

𝚒𝚗𝚝 𝚖𝚊𝚒𝚗() {
    𝚒𝚗𝚝 𝚊 = 𝟸; 
    𝚒𝚗𝚝 𝚋 = 𝟷; 
    𝚜𝚠𝚊𝚙(𝚊, 𝚋); 
    𝚊𝚜𝚜𝚎𝚛𝚝(𝚊 == 𝟷 && 𝚋 == 𝟸); 
}

Wo kommt es hier zu einem Problem und warum? Wie kann man es beheben?

Answer 1

Die Variablen 𝚡 und 𝚢 sind nur in der Funktion definiert, jedoch nicht ausserhalb. So macht die 𝚜𝚠𝚊𝚙-Funktion also rein gar nichts (auch wenn in der main-Function statt a und b erneut x und y verwendet werden.)

Das Programm bricht also bei der Assertion ab.

Um dies zu umgehen, macht man eine Referenz “&” zu den in der Funktion definierten Variablen, so dass das Programm weiss, auf diese Werte zugreifen zu müssen:

𝚟𝚘𝚒𝚍 𝚜𝚠𝚊𝚙(𝚒𝚗𝚝& 𝚡, 𝚒𝚗𝚝& 𝚢) {
…

Question 2

Sei 𝚃 ein Typ (z.B. 𝚒𝚗𝚝). Welche zwei Dinge hat der Referenztyp 𝚃& mit 𝚃 gemeinsam und welche sind anders und inwiefern?

Answer 2

Gleich sind Wertebereich und Funktionalität (𝚒𝚗𝚝 und 𝚒𝚗𝚝& repräsentieren z.B. beide die ganzen Zahlen und haben den gleichen Wertebereich).
Verschieden hingegen sind Initialisierung und Zuweisung:
- Eine Referenz muss mit einem L-Wert initialisiert werden.
- Die Variable wird dabei ein Alias des L-Werts .
- Zuweisung an die Referenz erfolgt an das Objekt hinter dem Alias.

Question 3

Betrachte die beiden Initialisierungen:
𝚒𝚗𝚝& 𝚓;
𝚒𝚗𝚝& 𝚔 = 𝟻;

Weshalb sind diese Initialisierungen ungültig?

Answer 3

𝚒𝚗𝚝& 𝚓; geht nicht, da 𝚓 das Alias von irgendetwas sein muss, so wird 𝚓 also keiner Adresse zugewiesen.
Bei 𝚒𝚗𝚝& 𝚔 = 𝟻; ist es ähnlich, da Literale (hier 𝟻) keine Adresse besitzen.

Question 4

Was bedeutet “Pass by Reference”?

Answer 4

Ein formales Argument wird intern mit der Adresse des Aufrufarguments (L-Wert) initialisiert und damit zu einem Alias.
Dies ist nur möglich, wenn das formale Argument einen Referenztyp hat.

Bsp.:
Sei 𝚓 eine in der main-Funktion deklarierte Variable und 𝚒 eine in einer anderen Funktion deklarierte Variable, so wird beim Aufrufen der Funktion 𝚒 mit 𝚓 initialisiert, die Funktion über 𝚒 ausgeführt und der Endwert von 𝚒 (immer noch innerhalb der Funktion) dann 𝚓 zugewiesen und in die main-Funktion “zurückgeschickt”.

Question 5

Was passiert, wenn das formale Argument keinen Referenztyp hat?

Answer 5

Es wird mit dem Wert des Aufrufarguments (R-Wert) initialisiert und damit zu einer Kopie.
Dies wird “Pass by Value” genannt.

Question 6

Was versteht man unter “Return by Reference”?

Answer 6

Dass der Rückgabetyp einer Funktion wiederum ein Referenztyp ist, z.B.:

𝚒𝚗𝚝& 𝚒𝚗𝚌(𝚒𝚗𝚝& 𝚒) {
𝚛𝚎𝚝𝚞𝚛𝚗 ++𝚒;
}

Der Aufruf 𝚒𝚗𝚌(𝚡) hat für eine 𝚒𝚗𝚝-Variable 𝚡 die selbe Semantik wie ++𝚡. Der Funktionsaufruf ist folglich selbst ein L-Wert, so dass Dinge möglich sind, wie:
𝚒𝚗𝚌(𝚒𝚗𝚌(𝚡)) oder ++(𝚒𝚗𝚌(𝚡)).

Question 7

Welches ist die Richtlinie für den Gebrauch von Referenzen?

Answer 7

Wenn man eine Referenz erzeugt, muss das Objekt, auf das sie verweist, mindestens so lange “leben”, wie die Referenz selbst.

Question 8

Welche der folgenden Initialisierungen funktioniert und warum?

(1) 𝚒𝚗𝚝& 𝚔 = 𝟻;
(2) 𝚌𝚘𝚗𝚜𝚝 𝚒𝚗𝚝& 𝚔 = 𝟻;

Answer 8

𝚒𝚗𝚝& 𝚔 = 𝟻; funktioniert nicht, da 5 als Literal kein L-Wert ist (also keine Adresse besitzen).
𝚌𝚘𝚗𝚜𝚝 𝚒𝚗𝚝& 𝚔 = 𝟻; ist hingegen möglich, da Referenzen auf Konstanten mit R-Werten initialisiert werden dürfen (es wird mit der Adresse eines temporären Objektes vom Wert des R-Wertes initialisiert).

Question 9

Betrachte die folgenden drei Initialisierungen:

(1) 𝚌𝚘𝚗𝚜𝚝 𝚒𝚗𝚝 𝚗 = 𝟻; 𝚒𝚗𝚝& 𝚊 = 𝚗; 𝚊 = 𝟼;
(2) 𝚒𝚗𝚝 𝚗 = 𝟻; 𝚌𝚘𝚗𝚜𝚝 𝚒𝚗𝚝& 𝚛 = 𝚗; 𝚛 = 𝟼;
(3) 𝚒𝚗𝚝 𝚗 = 𝟻; 𝚒𝚗𝚝& 𝚛 = 𝚗; 𝚛 = 𝟼;

Welche ist gültig und warum bzw. welche nicht und warum nicht?

Answer 9

(1) 𝚌𝚘𝚗𝚜𝚝 𝚒𝚗𝚝 𝚗 = 𝟻; 𝚒𝚗𝚝& 𝚊 = 𝚗; 𝚊 = 𝟼;
… ist nicht gültig, da 5 als konstant deklariert ist und somit nicht von der Referenz überschrieben werden darf.

(2) 𝚒𝚗𝚝 𝚗 = 𝟻; 𝚌𝚘𝚗𝚜𝚝 𝚒𝚗𝚝& 𝚛 = 𝚗; 𝚛 = 𝟼;
… ist nicht gültig, da das Aufrufargument als konstant definiert wird und somit danach nicht mehr überschrieben werden darf. (𝚌𝚘𝚗𝚜𝚝 𝚒𝚗𝚝& 𝚛 ist eine “read-only-reference”.)

(3) 𝚒𝚗𝚝 𝚗 = 𝟻; 𝚒𝚗𝚝& 𝚛 = 𝚗; 𝚛 = 𝟼;
… ist gültig, da nichts als konstant definiert wird und somit nicht überschrieben werden darf.

Question 10

Wann sollte man 𝚌𝚘𝚗𝚜𝚝𝚃& als Argumenttyp in einer Funktion verwenden?

Answer 10

Die Regel lautet:
Funktionsargumenttypen, falls möglich, als 𝚌𝚘𝚗𝚜𝚝𝚃& deklarieren, da effizient und sicher.
Man verspricht so, die Aufrufargumente nachträglich nicht mehr zu verändern.