Nochmal zum &-Zeichen, call by reference/value:
Das &-Zeichen ist im Prinzip ein Referenzierungsoperator.
In Verbindung mit Zeigern wird er genutzt, um die Adresse von z.B. Variablen zu ermitteln.
In dem Zusammenhang jedoch, also verbunden mit einem Datentyp (int& i, string& s),
bedeutet es, dass i oder s hier Referenzen sind (im Prinzip wie ein anderer Name für Variablen, die man zuweist).
Daraus folgt:
|
C-/C++-Quelltext
|
1
2
3
|
string t("test"); // String mit Literal "test" initialisieren
string& s = t; // s als "Alias" für t einführen
/* Über s kann nun direkt die Variable t verändert werden */
|
Wenn man nun die Parameter von Funktionen angibt, kann man sich
einprägen:
|
C-/C++-Quelltext
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
|
void functionVal(string sText);
void functionRef(string& sText);
string t("Tütensuppe"); // t mit "Tütensuppe" initialisieren
/* t wird an die Funktion übergeben und in der Funktion wird ein alte
Variable sText erstellt. Der Inhalt von t wird in sText kopiert und sText
kann als alte Variable in der Funktion verwendet werden. Jede Änderung
an sText würde folglich t nicht mehr verändern */
functionVal(t);
/* t wird an die Funktion übergeben und sText ist nun eine Referenz auf t.
Wenn man sText verändert, verändert man t!
Call-by-Reference arbeitet schneller als Call-by-Value und ist
daher für eigene Strukturen oder Klassen "geeignet" */
functionRef(t);
/* Nun soll aber der Inhalt von t in functionRef() nicht mehr verändert werden, weil
diese Funktion z.B. eines Konsolenausgabe macht.
Also fügt man das Schlüsselwort "const" hinzu, sodass die Referenz in der Funktion
konstant ist und man daran keine Veränderungen vornehmen kann */
functionRefConst(const string& sText);
|
Quintessenz: (string sText) == (const string& sText) (wobei sie natürlich nicht wirklich "gleich" sind; eher das Ergebnis)
Wobei Variante 1 für die Standarddatentypen und Variante 2 für eigene Strukturen oder Klassen "empfohlen" wird.