Wofür sind Referenzen und was machen sie?

[CarstenJ]

Und noch was: die Referenzen belegen keinen eigenen Speicher, die Zeiger schon. Dafür können die Referenzen aber auch nicht 'springen'.

Was du vielleicht meinst ist, dass wenn man Objekte per Referenzen übergibt, keine Kopie des Objekts angelegt werden muss, was natürlich auch Resourcen spart.

[Etyx]

Strogij schrieb:

int i = 1; // Eine int-Variable
int& j = i; // Eine int-Referenz, die auf i zeigt.

cout << j; // Es wird der Inhalt von i ausgegeben, da j auf i zeigt und nur ein anderer Name dafür ist

Und noch was: die Referenzen belegen keinen eigenen Speicher, die Zeiger schon. Dafür können die Referenzen aber auch nicht 'springen'.

hier hätte man doch auch die Referenz fallen lassen können oder?

[CarstenJ]

Ja.

Kommt aber immer drauf an was du machen willst, das Beispiel ist natürlich trivial. Es geht darum, dass du jetzt mit j arbeiten kannst, und in wirklich i veränderst. Sinnvoller sind Funktionen:

#include <iostream>
using namespace std;
void funk(int &j) // Die Referenz j ist ein anderer Name für i...
{
j++; // Erhöhe j um eins...
}
int main()
{
int i=6;
funk(i); // rufe die Funktion funkt mit i auf
cout << i; // Gib i aus: i wurde in der Funktion verändert, hieß dort aber j
}

[Zeus]

Strogij schrieb:

Und noch was: die Referenzen belegen keinen eigenen Speicher, die Zeiger schon. Dafür können die Referenzen aber auch nicht 'springen'.

Doch können Sie auch! oder ich weiss nicht was du meinst!

int a = 10;
int b = 20;

int& ref = a;
cout << ref << endl; 

ref = b;
cout << ref << endl;

[Etyx]

CarstenJ schrieb:

Ja.

Kommt aber immer drauf an was du machen willst, das Beispiel ist natürlich trivial. Es geht darum, dass du jetzt mit j arbeiten kannst, und in wirklich i veränderst. Sinnvoller sind Funktionen:

#include <iostream>
using namespace std;
void funk(int &j) // Die Referenz j ist ein anderer Name für i...
{
j++; // Erhöhe j um eins...
}
int main()
{
int i=6;
funk(i); // rufe die Funktion funkt mit i auf
cout << i; // Gib i aus: i wurde in der Funktion verändert, hieß dort aber j
}

[CarstenJ]

Hast du jetzt meinen Beitrag nicht verstanden, oder ich deine vorherige Frage nicht?!

Das hilft mir jetzt auch nicht weiter. Naja, wenn du dir die Tutorials mal durchgelesen hast, sollte es eigentlich klarer werden und beachte meinen Beitrag einfach nicht.

[interpreter]

Strogij schrieb:

Und noch was: die Referenzen belegen keinen eigenen Speicher, die Zeiger schon. Dafür können die Referenzen aber auch nicht 'springen'.

Doch können Sie auch! oder ich weiss nicht was du meinst!

C/C++ Code:
int a = 10;
int b = 20;

int& ref = a;
cout << ref << endl;

ref = b;
cout << ref << endl;

Strogij hatte mit seiner Aussage, dass Referenzen nicht "springen" können schon recht. in deinem Codebeispiel lässt du eben NICHT ref auf b zeigen, sondern kopierst den Wert von b nach a.

[Mis2com]

LOL, ihr seit ja nett, geht zu viert auf seine Aussage los.

MfG MAV

[Gast]

Hehe aber echt.. das mit keinen Speicher verbrauchen meinte ich so: Die Referenzen haben keinen eigenen Wert wie Variablen. Zeiger dagegen schon. Ich meinte nicht, dass man 10.000 Referenzen deklarieren kann, ohne Speicher im System zu verbrauchen. Habe ich jetzt soweit Recht oder nicht?
Ich stelle mir die Referenzen als zweiten Namen für eine übergebene Variable vor, Zeiger als eine eigenständige Einheit im Speicher mit einem Wert(Adresse im RAM).

[Gast]

Wie ich bereits sagte - Referenzen sind auch Zeiger.

[Gast]

Ja aber dann Zeiger auf einen Zeiger und konstant, oder?

[Etyx]

CarstenJ schrieb:

Hast du jetzt meinen Beitrag nicht verstanden, oder ich deine vorherige Frage nicht?!

Das hilft mir jetzt auch nicht weiter. Naja, wenn du dir die Tutorials mal durchgelesen hast, sollte es eigentlich klarer werden und beachte meinen Beitrag einfach nicht.

Ich deinen Beitrag nicht!
Was ich jetzt genau nicht verstehe ist:Was die genau machen!

[Zeus]

interpreter schrieb:

Strogij schrieb:

Und noch was: die Referenzen belegen keinen eigenen Speicher, die Zeiger schon. Dafür können die Referenzen aber auch nicht 'springen'.

Doch können Sie auch! oder ich weiss nicht was du meinst!

C/C++ Code:
int a = 10;
int b = 20;

int& ref = a;
cout << ref << endl;

ref = b;
cout << ref << endl;

Strogij hatte mit seiner Aussage, dass Referenzen nicht "springen" können schon recht. in deinem Codebeispiel lässt du eben NICHT ref auf b zeigen, sondern kopierst den Wert von b nach a.

Ja stimmt! Ich habe da was verwechselt! Referenzen werden bei der Deklaration definiert und können nicht mehr woanders hinzeigen!

[Gast]

Strogij schrieb:

Ja aber dann Zeiger auf einen Zeiger und konstant, oder?

Nein, es sind Zeiger.

int i;
int &ref = i;

ref zeigt jetzt auf i, enthält also die Adresse von i. Es ist genau wie bei Zeigern. Der einzige Unterschied ist, dass du die Referenz nicht neu zuweisen kannst. Sie wird für den Rest ihres Lebens auf i zeigen.
Klar kannst du dir es einfach als anderen Namen vorstellen, aber es ist technisch ein Zeiger. Deshalb verbraucht die Referenz genauso wie ein Zeiger 4Bytes Speicherplatz auf einem 32-Bit System.

[Gast]

Danke dir, der Grund für meine Aussage waren wohl die Referenzen bei PHP, aber das ist ja ein ganz anderer Witz.
PS: Ich hoffe der Autor versteht es jetzt...

[HumeSikkins]

@Optimizer
Könntest du deine Aussage bitte mal belegen? Ich sehe das nämlich etwas anders. Und zwar so:
Referenzen werden häufig (keinesfalls immer) über Zeiger implementiert, und
belegen dann auch genausoviel Speicher wie ein Zeiger.
Der Standard schreibt dies aber nicht vor.

Desweiteren benötigen Referenzen nicht zwangsläufig Speicher.
Vielmehr brauchen sie selbigen nur in speziellen Situationen, z.B. als Funktionsparameter oder Rückgabewerte.
Lokale (gloable) Referenzen müssen aber keinen Speicher belegen, da Refernzen nur Aliasnamen für andere Objekte sind. Sind sind selbst aber keine Objekte mit einer eindeutigen Identität, sie sind nicht direkt adressierbar und müssen demzufolge auch keinen eigenen Speicherbereich besitzen.

[SirLant]

HumeSikkins schrieb:

@Optimizer
Könntest du deine Aussage bitte mal belegen? Ich sehe das nämlich etwas anders. Und zwar so:
Referenzen werden häufig (keinesfalls immer) über Zeiger implementiert, und
belegen dann auch genausoviel Speicher wie ein Zeiger.
Der Standard schreibt dies aber nicht vor.

Desweiteren benötigen Referenzen nicht zwangsläufig Speicher.
Vielmehr brauchen sie selbigen nur in speziellen Situationen, z.B. als Funktionsparameter oder Rückgabewerte.
Lokale (gloable) Referenzen müssen aber keinen Speicher belegen, da Refernzen nur Aliasnamen für andere Objekte sind. Sind sind selbst aber keine Objekte mit einer eindeutigen Identität, sie sind nicht direkt adressierbar und müssen demzufolge auch keinen eigenen Speicherbereich besitzen.

Wenn ich deine Aussage hier richtig verstehe, meinst du das gleiche wie ich.
Ich denke die meisten Referenzen kann der Compiler wegoptimieren um Speicher
zu sparen nur wenn es an das übergeben an Funktionen geht, dann benötigt man
die Adresse.

Das meinst du doch auch oder?

[Bashar]

Zeiger kann er auch wegoptimieren, das kanns also nicht sein.

[HumeSikkins]

Das meinst du doch auch oder?

Yup. Der Standard schreibt nicht vor, wieviel Speicher bzw. ob Referenzen Speicher belegen (es gibt in Standard-C++ auch keine Möglichkeit dies herauszubekommen oder Speicherbelegung zu erzwingen)
Wenn es also keine zusätzlichen Zwänge gibt (z.B. Referenz als Membervariable oder als Funktionsparameter) und der Compiler clever genug ist, dann kann eine Referenz durchaus auch ohne eigenen Speicherbereich (zur Laufzeit) implementiert werden.
Gerade für lokale Referenzen dürften die meisten Compiler das wohl machen.

[lousypoetry]

Was ich jetzt genau nicht verstehe ist:Was die genau machen!

Auf auf die Gefahr hin dass mein Fachwissen noch sehr bescheiden ist, aber da ich mich auch grad mit Refernzen beschäftigt hab find ich CarstenJ's Beispiel ganz verständlich

#include <iostream> 
using namespace std; 

void funk(int &j) // Die Referenz j ist ein anderer Name für i... 
{ 
j++; // Erhöhe j um eins... 
} 
int main() 
{ 
int i=6; 
funk(i); // rufe die Funktion funkt mit i auf 
cout << i; // Gib i aus: i wurde in der Funktion verändert, hieß dort aber j 
}

In der Main-Funktion hast du eine Variable i mit derm Wert 6. Die Funtion funk übernimmt jetzt i als Argument (funk(i)) und wird ausgeführt, jedoch heißt der Parameter der Funktion nicht j sondern &j, was die Referenz kennzeichnet.
Wäre j keine Referenz, so würde i in der Main-Funktion nicht verändert werden und wäre also immer noch 6. Da j aber eine Referenz ist, wird i verändert und ist jetzt 7.

Ich hoffe, das ist soweit richtig, wenn nicht korrigiert mic bitte, will ja nichts Falsches hier verbreiten...