return wert als inout parameter die 2. Funktion übergeben

netrobot

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?

FireFlow

netrobot schrieb:

ist es compiler abhängig?

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

Frage -> Antwort.

netrobot

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?

FireFlow

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).

netrobot

warum

DoWith(++k); // work fine

aber nicht

DoWith(k++);

joomoo

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.

FireFlow

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.

netrobot

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.

joomoo

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.

Vellas

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.