Um ev. ein bischen zum Allgemeinen Verständnis beizutragen.
Wenn du eine Funktion hast und die dann aufrufst und einen Wert übergibst, dann wird der IMMER kopiert, respektive das Objekt mit dem jeweiligen Wert initialisiert.
|
C-/C++-Quelltext
|
1
2
3
4
5
6
7
8
|
void foo (int i)
{...}
..
foo ( 2 );
//da wird jetzt nichts anderes gemacht, als:
int i = 2; //natürlich in der Funktion, was gleichbedeutend ist mit:
int i ( 2 ); //Initialisierung eines Integers mit 2
|
Das ganze Verhält sich genau gleich bei Zeigern:
|
C-/C++-Quelltext
|
1
2
3
4
5
6
7
8
|
void foop (int* i)
{...}
int n = 2;
foop ( &n );
//ist das gleiche, wie
int* i = &n; //und:
int* i ( &n );
|
Merke bei den Zeigern, dass es sich um einen anderen Datentypen handelt, mit dem du arbeitest. Nämlich Zeiger auf Integer. Aber dieser Datentyp muss auch einen Wert bekommen, welcher ebenfalls kopiert werden muss.
Und zum Schluss das ganze noch mit einer Struktur:
|
C-/C++-Quelltext
|
1
2
3
4
5
6
7
8
9
10
11
12
|
struct bar
{...};
void foos ( bar b )
{...}
bar a;
foos ( a );
//ist gleich:
bar b = a; // gleich:
bar b ( a ); // [1]
|
Man beachte aber, dass das mit der Zuweisung = Initialisierung lediglich bei der Deklaration gilt und auch nur, wenn ein entsprechender Konstruktor zur Verfügung steht.
Und wenn wir hier schon von Konstruktoren reden, dann darf natürlich auch der Verweis zum Kopierkonstruktor fehlen, den wir bei [1] in Aktion sehen. Und hier wirds auch gleich wieder interessant.
Aber um das ganze jetzt hier aufzuführen ist mir die Zeit zu schade, weil das bereits oft gemacht wurde.
Darum gibts nur ein paar weiterführende Links zu dem Thema:
Wikipedia
http://tutorial.schornboeck.net/operatoren_ueberladung.htm
string-Beispiel von David_pb