pointer als Funktionsparameter - per Referenz?

[ne0r]

(Hoffe ich habe mich nicht im Titel vertan..)

Mann kann ja einer Funktion eine Variable per Referenz übergeben:

void bla(int &i);

zum Beispiel.

Aber was ist, wenn ich einer Funktion einen Pointer per Referenz übergeben will?

void blap(int &*p);

(haha, geht natürlich nicht.)

???

[ten]

geht das nicht?
ich kann c++ nicht so gut, aber eigentlich sollte das möglich sein, wenn man eine pointervariable verändern will (ähnlich wie's mit einem doppel-* geht)...
:xmas2:

[Gast]

natürlich geht das, man muß es nur richtig schreiben.

int p; <- eine int-variable
int* p, <- ein int-zeiger
int& p; <- eine referenz auf int
int*& p; <- eine referenz auf einen int zeiger.

int&* p; <- Unsinn

[ne0r]

Ah, danke!

[Shinja]

Kurze Anfrage zur Begründung. Meine Meinung: das geht nicht, weil man den Speicher an dem eine Referenz steht nicht ändern kann, sondern nur das, worauf dieser Speicher zeigt. Ergo macht ein Pointer auf eben diesen Speicher gar keinen Sinn.

Aber irgendwie glaub ich, dass das falsch erklärt ist (vielleicht aber richtig gemeint, lol)

[Gast]

Shinja schrieb:

Kurze Anfrage zur Begründung. Meine Meinung: das geht nicht, weil man den Speicher an dem eine Referenz steht nicht ändern kann, sondern nur das, worauf dieser Speicher zeigt. Ergo macht ein Pointer auf eben diesen Speicher gar keinen Sinn.

Aber irgendwie glaub ich, dass das falsch erklärt ist (vielleicht aber richtig gemeint, lol)

Falsch erklärt und auch falsch gemeint Referenz hat nichts mit "nicht ändern können" zu tuen und Referenzen "zeigen" auch nicht auf irgendwas.

Betrachte folgendes Stück Code:

void func(int i) {
   i++;
}

int main() {

   int x;
   func(x);
}

Was hier beim Aufruf der Funktion passiert ist, daß für i neuer Speicher reserviert wird und der Inhalt von x nach i kopiert wird. Die Funktion arbeitet also mit einer Kopie von x. Ändert man jetzt i, wird x nicht geändert, weil dies zwei voneinander unabhängige Speicherbereiche sind.

void func(int& i) {
   i++;
}

int main() {

   int x;
   func(x);
}

Mit der Referenz sagen wir jetzt dem Compiler, daß er für i keinen neuen Speicher reservieren soll, sondern das er den gleichen Speicherbereich benutzen soll den er bereits für x reserviert hat. i ist also keine eigenständige Variable, sondern lediglich ein alias auf x. Da sich beide Variablen den gleichen Speicher teilen, wird die Änderung innerhalb von func auch im main sichtbar.

UNd wie ist das jetzt mit der Referenz auf den Zeiger? Nun, ein Zeiger ist erstmal nichts anderes als eine normale Variable, nur das der Inhalt dieser Variablen eine Speicheradresse ist. Für den Zeige selbst gilt also das gleiche wie für eine ganz normale Variable. Das man einen Zeiger zusätzlich dazu benutzen kann, um Speicherinhalte zu manipulieren ist zweitrangig. Darauf hat die Referenz keinen Einfluß.

[Shinja]

hmm, ich hatte irgendwo mal als beschreibung für referenz "ein sich selbst dereferenzierender Zeiger" oder so ähnlich gelesen.

Was genau bewirkt nun eine Referenz (wie eben in der Funkion von schue angegeben) Ich weiss wie ich sie nutze und was ich damit machen kann, aber was genau passiert wenn das & vor eine Variable scheibe (also intern) weiss ich nicht. Wird da nun ein eigener (kleiner) Speicherberreich der die Adresse abspeichert und der compiler sorgt dafür dass ich nicht zu dereferenzieren brauche?

Sekunde, ich merke woran mein Verständnisproblem eigentlich hängt: wie macht der pc es um die Verbindung zwischen der Variablen i im Programm und ihrem Speicherberreich zu machen?? Also woher weiss er wenn ich i schreibe auf welchen speicher er zugreifen soll??

EIgentlich scheint mir das eine grundlegende Verständnisfrage zu sein, ob sie jetzt einfach, recht dumm, intelligent oder schwierig ist weiss ich erst wenn ic ne antwort habe, hehe.

EDIT: ok, nach ner längeren Diskussion glaube ich eine ungefähre idee bekommen zu haben.

ps: dass ich wenn ich int& x=i schreibe dnn mit x auf den gleichen Speicherberreich zugreife wie mit i war mir klar... aber das mache ich mit int* p=&i auch, bloss dann halt mit *p statt wie vorher einfach mit x. Und dass ich p jetzt auch woanders hinzeigen lassen kann, x hingegen quasi gebunden ist. Wie gesagt, wie ichs verwende ist klar, bloss halt das dahinter ist jetzt so ne Sache.

[Gast]

Shinja schrieb:

ps: dass ich wenn ich int& x=i schreibe dnn mit x auf den gleichen Speicherberreich zugreife wie mit i war mir klar... aber das mache ich mit int* p=&i auch, bloss dann halt mit *p statt wie vorher einfach mit x. Und dass ich p jetzt auch woanders hinzeigen lassen kann, x hingegen quasi gebunden ist. Wie gesagt, wie ichs verwende ist klar, bloss halt das dahinter ist jetzt so ne Sache.

Nein, genau da liegt der Verständnisfehler begraben.

int i;
int& x=i;

Bedeutet, das x und i ein- und dieselbe Variable sind und die gleiche Stelle im Speicher belegen. Daher kann man hier x auch als ein Alias auf i betrachten. In diesem Beispiel gibt es nur genau eine Variable (i). x ist nur ein anderer Name für i, keine eigenständige Variable.

int i;
int* p = &i;

Dagegen haben wir es hier mit zwei Variablen zu tuen. i ist eine Variable die einen bestimmten Speicherbereich belegt. Soweit das gleiche wie im ersten Fall.

p aber ist ebenfalls eine eigenständige Variable und belegt eigenen Speicher. der Inhalt von p ist die Speicheradresse der Variablen i. Mit *p kann ich auf das zugreifen, worauf der Zeiger zeigt, in dem Fall die variable i.

Aber wie gesagt, der entscheidende Unterschied ist, das im Zeiger-Fall zwei Variablen existieren, im Referenzfall nru eine.

[Shinja]

Hmm, irgendwie bezweifle ich aber, dass der compiler bei der anwendung dann jedesmal x durch i ersetzt. Ich würde immer noch eher sagen, dass i und x 2 Variablen sind, die den gleichen Speicherberreich benutzen.

Naja, für die Benutzung macht es keinen Unterschied. Aber irgendwie hab ich ein kleines Problem damit, mir eine Variable mit 2 Namen vorzustellen... irgendwie eher 1 Speicherbereich der unter 2 Variablennamen zugänglich ist.

Ist diese Interpretation tatsählich so grundlegend falsch??

[Gast]

Beim Programmieren geht es vor allem um Genauigkeit. Es reicht nicht, wenn es ungefähr so ist Dicht daneben zählt nur bei Handgranaten noch als Treffer...

Es ist halt ein Unterschied, ob Du zwei Variablen hast, die sich einen Speicher teilen oder ob Du eine Variable hast, die im Sourcecode nur unter zwei Namen bekannt ist. Btw, sowas wie Variablennamen sind nur eine Hilfe für uns Menschen, damit wir den Code besser lesen können, auf Maschienenebene gibt es diese Namen nicht mehr. Für den Compiler ist es daher tatsächlich genau die gleiche Variable.

Zitat aus C++, die Programmeirsprache (Seite 105, 3te Auflage):
" Eine Referenz ist ein alternativer Name für ein Objekt "

Die Referenz ist also keine Variable, sondern nur ein Name (Alias).

[ne0r]

Frage:

Sind denn dann Referenzen (int& x = i) und Adressen (int* x = &i) zwei grundverschiedene Dinge, oder eng miteinander verwand, oder eigentlich ein-und-dasselbe (für den Compiler) , nur dass wir es auseinernanderhalten müssen?