Unterschied: Referenz& und *Pointer

Eine Referenz kann aber nie auf NULL zeigen, im Gegensatz zu einem Zeiger.

Bashar

Hammer: Genau, aber nicht nur Schreibarbeit. Ohne Referenzen müßte man zb bei einem überladenen Zuweisungsoperator sowas schreiben: a = &b; was die ganze Sache nicht mehr ganz so sinnvoll macht ...

Hammer

void foo1(int * a)
{
if(a == NULL)
return;
a = 12;
}

das muss:

void foo1(int * a)
{
  if(*a == NULL)
    return;
  *a = 12;
}

heissen ...

Bashar

Referenzen schützen nicht vor Nullpointern! Es ist lediglich undefiniert, was bei folgendem Programm passiert:

void foo(int &a) {
  if (&a)
    a = 12;
}

int main() {
  int *p = 0;
  foo(*p);
}

GCC schluckt das anstandslos ...

Lars

Original erstellt von Dimah:
...nie NULL oder wild sein können

void func(int&);
int* pInt;
int& rInt = *pInt;
func(rInt);

Und ich glaube das ist gar nicht so unrealistisch das eine Referenz mal ausversehen durch fehlerhaften Code auf bereits freigegeben Spicher o.ä. zeigt.

HumeSikkins

Referenzen schützen nicht vor Nullpointern!

Naja, auf Semantikebene schon. Ein Refernz-Parameter deutet an, dass die Funktion immer einen gültiger Wert erwartet. Ein Pointer-Parameter zeigt an, dass auch ein "sentinel value" (wer kennt eine schöne deutsche Übersetzung?) in Form des Nullzeigers möglich ist.

void foo(int &a) {
if (&a)
a = 12;
}

int main() {
int *p = 0;
foo(*p);
}

Wer sowas macht hat pech gehabt. So wie ich den Standard lese, gibt es keine Möglichkeit für foo die Situation zu retten, da das Kind bereits vorher in den Brunnen gefallen ist.

Entyl_Sa

Also zwischen Pointern und Referencen gibt es auf jeden Fall einen Unterschied, mir fallen die zwar jetzt alle nicht ein, aber ich hab das auch mal gewusst.

Das da genauso Fehler auftreten koennen, wenn ich da wild irgendwelche Pointer reinhaue oder sonst irgendwas mach ist ja wohl auch klar, aber wenn ich das benutze wie bei call by value dann sollte es eigentlich keine Fehler machen.

Dann kann man Referencen auch const machen f(const int& i) was ja bei Pointer nicht geht.

Bashar

Dann kann man Referencen auch const machen f(const int& i) was ja bei Pointer nicht geht.

foo(const int * pi) /* lalala */

foo(const int * const pi) /* lalala */

so gehts doch?

Entyl_Sa

ich sag ja das das lange her ist

HumeSikkins

Dann kann man Referencen auch const machen

Nö. In C++ sind alle Referenzen const. Ein explizites const für eine Referenz ist verboten.
Also:
Es gibt Referenzen (implizit const) (Bsp: int&)
Es gibt Referenzen auf const (Bsp: int const&)
Es gibt Zeiger (Bsp: int*)
Es gibt Zeiger auf const (Bsp: int const*)
Es gibt const Zeiger (Bsp: int const)
Es gibt const Zeiger auf const. (Bsp: int constconst)

Es gibt keine const Referenzen (Bsp: int& const)
Es gibt keine const Referenzen auf const.(Bsp: int const&const)

foo(const int * const pi) /* lalala */

Das ist genauso überflüssig wie
foo(const int);
und aus Überladungssicht genau das gleiche wie
foo(const int * pi)

Bedenke. Der Zeiger wird "by value" übergeben.

[ Dieser Beitrag wurde am 28.03.2003 um 13:47 Uhr von HumeSikkins editiert. ]

Drakos

Ich bin grad etwas verwirrt.
Wäre bei

*```cpp
foo(const int * pi) / lalala */

pi nicht ein konstanter Zeiger, sprich der Wert von pi wäre const?
Imho wäre dann bei

foo(const int &i)

das i durch die Konstante quasi ein unveränderlicher Alias der übergebenen Variable. Denn Zeiger werden ja per value übergeben und Referenzen eben nicht.
Deswegen sollte man ja grad Referenzen verwenden, da keine Kopie angelegt wird und somit Speicher gespart und Performance gewonnen wird. Oder liege ich da falsch?

Gerard

Ich bin grad etwas verwirrt.
Wäre bei[quote] *```cpp
foo(const int * pi) / lalala */

pi nicht ein konstanter Zeiger, sprich der Wert von pi wäre const?
[/QUOTE]
ne pi ist ein nicht konstanter Zeiger (adresse die i.d.r. 4 byte braucht)(der per value übergeben wird) auf ein konstantes int,
der wert von pi ist nicht const, der wert von pi ist irgend so eine komische speicher adresse, aber die bytes die sich an dieser speicher adresse befinden dürfen nicht geändert werden

Imho wäre dann bei
foo(const int &i)
das i durch die Konstante quasi ein unveränderlicher Alias der übergebenen Variable. Denn Zeiger werden ja per value übergeben und Referenzen eben nicht.
Deswegen sollte man ja grad Referenzen verwenden, da keine Kopie angelegt wird und somit Speicher gespart und Performance gewonnen wird. Oder liege ich da falsch? [/QB]

i.d.r. werden referenzen intern über pointer implementiert

das ist ja das witzige: Referenzen werden immer by Value übergeben. Es gibt (noch?) keine Referenzen auf Referenzen. Auch ein Unterschied zu Zeigern.

zu früh auf "antwort erstellen" geklickt

wollt noch schnell ein code beispiel machen:

void neuerZeiger (const int * & ptr_ref) {
    ptr_ref = new int(14);
}
//ist pferdevalent zu
void neuerZeiger (const int * * ptr_ptr) {
    *ptr_ptr = new int(14);
}

//aber das geht nicht:
void neueReferenz (const int & & ref_ref) {
    ref_ref = ???; //was sollte ich den hier tun, eine referenz ist immer const...
}

Drakos

Original erstellt von Dimah:
i.d.r. werden referenzen intern über pointer implementiert

Und wie seht das dann genau aus?

Drakos

Original erstellt von <hups>:
**zu früh auf "antwort erstellen" geklickt

wollt noch schnell ein code beispiel machen:

void neuerZeiger (const int * & ptr_ref) {
    ptr_ref = new int(14);
}
//ist pferdevalent zu
void neuerZeiger (const int * * ptr_ptr) {
    *ptr_ptr = new int(14);
}

//aber das geht nicht:
void neueReferenz (const int & & ref_ref) {
    ref_ref = ???; //was sollte ich den hier tun, eine referenz ist immer const...
}

**

Das ist klar. Es ging ja eigentlich auch mehr um die Sache

const int &i

vs.

const int *pi

.

Compiler Magie!
Eine Referenz == ein konstanter Zeiger, der nicht mit null initialisiert werden darf, und nicht dereferenziert werden muss
Also macht der Compiler aus jeder Referenz einen Zeiger und schaut sich dabei schön brav die regel oben an

Gerard

Original erstellt von Drakos:
Und wie seht das dann genau aus?

stelle dir vor dein compiler macht aus

void foo(int & i)
{
    i = 100;
}

ein

void foo(int * i)
{
    (*i) = 100;
}

natürlich macht es das nicht so, sondern das leuft auf anderer ebene ab (aber wenn ich ein c++ compilier bauen sollte der ein c compilier benutzt dann würde ich das so machen)

finde der standard sollte vorschreiben, dass undefiniertes verhalten das programm zu terminieren hat (oder von mir aus nur ne exception). außer man deklariert seine funktion als "undefined" dann würde eine 0 Referenz nicht mehr vorkommen

Unterschied: Referenz&amp; und *Pointer

Unterschied: Referenz& und *Pointer