return wert als inout parameter die 2. Funktion übergeben

Reply to return wert als inout parameter die 2. Funktion übergeben on Fri, 16 Jun 2006 20:36:38 GMT

netrobot — Fri, 16 Jun 2006 20:36:38 GMT

int retInt()
{
   int i = 10;
   return i;
}

void DoWith(int& inoutPara)
{
   inoutPara ++;
}

int main()
{
   DoWith(retInt()); //error C2664: 'DoWith' : 
                     //cannot convert parameter 1 
                     //from 'int' to 'int &'
   int j = retInt();
   DoWith(j);
   int k = 100;
   DoWith(k++); //error C2664: 'DoWith' : 
                //cannot convert parameter 1 
               //from 'int' to 'int &'
   DoWith(++k); // work fine

   return 0;
}

ist es compiler abhängig?

Reply to return wert als inout parameter die 2. Funktion übergeben on Fri, 16 Jun 2006 20:57:04 GMT

FireFlow — Fri, 16 Jun 2006 20:57:04 GMT

netrobot schrieb:

ist es compiler abhängig?

Nein das ist schon alles richtig so wie es der Compiler macht.

Frage -> Antwort.

Reply to return wert als inout parameter die 2. Funktion übergeben on Fri, 16 Jun 2006 21:00:42 GMT

netrobot — Fri, 16 Jun 2006 21:00:42 GMT

dann Frage:

DoWith(retInt()); //error C2664: 'DoWith' :
                     //cannot convert parameter 1
                     //from 'int' to 'int &'

bzw.

DoWith(k++); //error C2664: 'DoWith' : 
                //cannot convert parameter 1 
               //from 'int' to 'int &'

wieso?

Reply to return wert als inout parameter die 2. Funktion übergeben on Fri, 16 Jun 2006 21:05:00 GMT

FireFlow — Fri, 16 Jun 2006 21:05:00 GMT

Die Fehlermeldungen sind wirklich schlecht, das stimmt. Das hier sagt der g++, sollte dann auch klar sein:

code.cpp: In function 'int main()':
code.cpp:14: error: invalid initialization of non-const reference of type 'int&' from a temporary of type 'int'
code.cpp:7: error: in passing argument 1 of 'void DoWith(int&)'
code.cpp:20: error: invalid initialization of non-const reference of type 'int&' from a temporary of type 'int'
code.cpp:7: error: in passing argument 1 of 'void DoWith(int&)'

Temporarys können nicht an non-const Referenzen gebunden werden (ich hoffe das stimmt so).

Reply to return wert als inout parameter die 2. Funktion übergeben on Fri, 16 Jun 2006 21:09:19 GMT

netrobot — Fri, 16 Jun 2006 21:09:19 GMT

warum

DoWith(++k); // work fine

aber nicht

DoWith(k++);

Reply to return wert als inout parameter die 2. Funktion übergeben on Fri, 16 Jun 2006 21:12:13 GMT

joomoo — Fri, 16 Jun 2006 21:12:13 GMT

netrobot schrieb:

warum

DoWith(++k); // work fine

aber nicht

DoWith(k++);

wenn du den Unterschied zwischen ++k und k++ kennst, sollte das klar sein: ++k braucht kein temporäres Objekt erstellen, sondern nur eine referenz auf k zurückgeben. k++ hingegen muss dies tun.

mfg.

Reply to return wert als inout parameter die 2. Funktion übergeben on Fri, 16 Jun 2006 21:16:14 GMT

FireFlow — Fri, 16 Jun 2006 21:16:14 GMT

Weil ++k zuerst k erhöht und dann wieder eine Referenz auf k zurück gibt.

Bei k++ wird aber k erhöht und dann eine Kopie des alten k zurück gegeben, genau wie bei deiner Funktion retInt bekommst du hier ein Temporary.

Reply to return wert als inout parameter die 2. Funktion übergeben on Fri, 16 Jun 2006 22:35:23 GMT

netrobot — Fri, 16 Jun 2006 22:35:23 GMT

Bei k++ wird aber k erhöht und dann eine Kopie des alten k zurück gegeben

wieso ist es nicht möglich ein referenz zurückzugeben.

Reply to return wert als inout parameter die 2. Funktion übergeben on Fri, 16 Jun 2006 22:38:45 GMT

joomoo — Fri, 16 Jun 2006 22:38:45 GMT

netrobot schrieb:

Bei k++ wird aber k erhöht und dann eine Kopie des alten k zurück gegeben

wieso ist es nicht möglich ein referenz zurückzugeben.

Eine Referenz auf was? Auf das alte k? Das ist doch möglich: Nämlich mit ++k. Oder was meinst du jetzt?

mfg.

Reply to return wert als inout parameter die 2. Funktion übergeben on Fri, 16 Jun 2006 22:51:06 GMT

Vellas — Fri, 16 Jun 2006 22:51:06 GMT

Weil der Rückgabewert, wie bereits gesagt, eine temporäre Variable ist. Die Implementierung könnte z.B. so aussehen:

int Postincrement(int &value) {
  int tmp = value;
  value += 1;
  return tmp;
}

Dadurch würde bei einer Zuweisung der alte Wert zurückgegeben und value erhöht werden. tmp wird nach Beendigung der Funktion zerstört, wenn du dann eine Referenz auf tmp zurückgibst, würdest du dich auf ein ungültiges Objekt beziehen. Die Initialisierung einer Variablen mit dem Rückgabewert mit einer Referenz von tmp ist somit undefiniert. Also bleibt dir nur übrig eine Kopie zurückzugeben.

Die Präfix-Variante hingegen etwa so:

int& Praeincrement(int &value) {
  return value+=1;
}

Hier wird value erhöht. Da hier keine neue Variable angelegt wird, kann eine Referenz zurückgegeben werden, diese bezieht sich dann auf die an Praeincrement übergebene Variable und somit auf ein Objekt, welches auch nach verlassen der Funktion gültig ist.