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?

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.

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                                                 
}

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