# operator[] warum referenz zurückgeben?



## maniacquaker (30. November 2006)

Hallo,
ich wollte für eine selbst geschriebene vektor klasse den [] operator überladen.
das ganze sollte ungefähr so aussehen:

double& vec:perator[](double i){

            switch(i){
            case 0: return x; break;
            case 1: return y; break;
            case 2: return z; break;

            }
}

warum gibt man da eine referenz zurück? also ich meine auch generell. was macht es für einen unterschied wenn ich nur einen normalen double zurückgebe?
warum funktioniert das überhaupt? man referenziert doch auf eine variable die es außerhalb der funktion gar nicht mehr gibt!

bitte um alle informationen dahingehen da man leider nur vereinzelte und widersprüchliche infos im netz bekommt.

danke und gruß


----------



## RedWing (30. November 2006)

Hallo,

eine Referenz gibst du deshalb zurück das du den operator auch als lvalue in einer
Zuweisung verwenden kannst:


```
vec test;
test.add(1.0);
test.add(2.0);
test[1] = 3.14; //<--- hier muss eine Referenz von Operator[] zurückgegeben werden ansonsten geht sowas nicht
```

x, y, z sollten nat. Member deiner Klasse sein, und nicht lokal im Operator[] angelegt werden.

Gruß,
RedWing


----------



## maniacquaker (30. November 2006)

ok ich verstehe, dass man es machen muss aber WARUM genau? was passiert da im speicher?

wo liegt der unterschied zwischen
	
	
	



```
test[i]=3.42;
```
 und 
	
	
	



```
int j = test[i]
```
 ?

eine möglichst detailiert erklärung würde mir mehr helfen. Ich habe etwas erfahrung in assembler und meine c++ kenntnisse sind auch nicht auf anfänger niveau (denke ich ^^) und ich weiss was ein stack ist und wie er aufgebaut ist, daher könnt ihr mich mit details ruhig überfordern.

!änderung:!
hm ich habe mir nochmal gedanken dazu gemacht und mir ist folgendes eingefallen:

der gleich operator wird ja für das ergebnis aus a[ i ] mit dem rwert als parameter aufgerufen. wenn man nun beim operator[] keine referenz zurückgibt sondern nur einen double hat man keine variable, für dessen typ man den = operator mit dem rwert als parameter aufrufen kann.  richtig? tut mir leid aber ich will es immer genaustens wissen. danke


----------



## Flegmon (1. Dezember 2006)

Zu deinen Gedankengängen am Schluss kann ich nix sagen ^^, aber um auf den Unteschied zwischen einem einfachen Double und ner Referenz zu kommen

Wenn du double als Rückgabewert hast, dann wird nur der Wert selbst zurück gegeben.
Eine zuweißung per 
	
	
	



```
a[i] = 1;
```
 würde nicht funktionieren. 
	
	
	



```
var = a[i];
```
 funktioniert hingegen, da der Wert ja zurückgegeben wird.

Eine Referenz ist nur ein andrer Name für ne Variable
arbeitest du also mit Referenzen, ist das so, als würdest du direkt mit der Variable arbeiten

```
a[i] = 1;
```
 speichert also 1 in die Variable und 
	
	
	



```
var = a[i];
```
 holt den Wert aus der einen Variable und speichert ihn in die andre.


vllt wirds so deutlicher


```
void func(int a)
{
   a = 1;
}

void func2(int& a)
{
  a = 1;
}

int main()
{
  int a = 0;
  func(a);
   // a ist immernoch 0
  func2(a); 
  // diesma wurde die variable weitergegeben und nicht nur der Wert -> a = 1
...
```


----------



## maniacquaker (1. Dezember 2006)

ja genau und ich habe auch geschrieben warum es nur mit dem wert nicht funktioniert. eine variable hat einen typ, ein wert nicht. deshalb kann der = operator dann nicht für einen wert (wenn man keine referenz zurückgibt) aufgerufen werden.

jetzt gibt es aber trotzdem noch etwas zu klären:

bei einer funktion werden die ganzen variablen auf den stack gepusht .... alles 100 mal gehört. nach der funktion werden sie alle wieder gepoppt und verlieren deshalb ihre gültigkeit. wenn ich jetzt eine referenz zurückgebe, wird der zugewiesene wert ja nur ein alias für die variable, die ich aus der funktion zurückgegeben habe. aber die ist doch gar nicht mehr da? oder doch?


----------



## RedWing (1. Dezember 2006)

maniacquaker hat gesagt.:
			
		

> wenn ich jetzt eine referenz zurückgebe, wird der zugewiesene wert ja nur ein alias für die variable, die ich aus der funktion zurückgegeben habe. aber die ist doch gar nicht mehr da? oder doch?



Ja deswegen deklarierst du deine funktionslokale Variable auf die du eine Referenz
zurückgeben willst  entweder static, oder machst sie global verfügbar. Im 
objektorientierten Kontext bedeutet dass:



			
				RedWing hat gesagt.:
			
		

> x, y, z sollten nat. Member deiner Klasse sein, und nicht lokal im operator[] angelegt werden.



Gruß,
RedWing


----------

