Temporaries und constcorrectness

hallo alle

folgender code:

struct foo { void f() {} };

void f(foo&) { }

int main()
{
	foo().f(); //geht
	f(foo()); //geht nicht
}

wieso geht die erste version, die das temporary u.u. verändert, aber nicht die zweite, die es auch tut?

Swordfish

Weil temporaries nicht an non-const references gebunden werden dürfen?

und was ist der hintergrund? wieso sollte ich ein objekt verändern dürfen, es jedoch nicht an eine nonconst ref binden dürfen?

volkard

Konstantinopel schrieb:

und was ist der hintergrund? wieso sollte ich ein objekt verändern dürfen, es jedoch nicht an eine nonconst ref binden dürfen?

Dann machst nicht als temporäre Variable.

foo g;
    f(g);

Wenn Du g verändern willst, brauchsate doch nach dem Aufruf auch nen Namen, um es anzufassen.

Swordfish

Es geht ihm um den Grund warum man ein temporary nur an eine const reference binden kann ...

Es gibt Workarounds:

struct foo {
  foo& self() { return *this; }
  void f() {}
};

void f(foo&) { }

int main()
{
  foo().f(); //geht                                                             
  f(foo().self()); //geht                                                 
}

Oder mit einem schönen Pattern:

template <typename T>
struct self_crtp {
  T& self() { return *static_cast<T*>(this); }
};

struct foo : self_crtp<foo> {
  void f() {}
};

int main()
{
  foo().f(); //geht                                                             
  f(foo().self()); //geht                                                 
}

volkard

Swordfish schrieb:

Es geht ihm um den Grund warum man ein temporary nur an eine const reference binden kann ...

Stroustrup schrieb:

That's to protect people from changing the values of temporaries that are destroyed before their new value can be used.

http://stroustrup.com/C++11FAQ.html#rval