C ++中的临时对象

Question

I was going through reference return and came across temporary objects. I don't understand how to identify them. Please explain using this example:

If a and b are objects of same class, consider binary operator+ . If you use it in an expression such as f(a+b) , then a+b becomes temporary object and f has to of form f(const <class name>&) or f(<class name>) . It can't be of form f(<class name>&) However, (a+b).g() is perfectly alright where g() can even change contents of object returned by a+b .

Answer 1

When you say f(a + b) , the parameter of f needs to bind to the value with which the function was called, and since that value is an rvalue (being the value of a function call with non-reference return type)*, the parameter type must be a const-lvalue-reference, an rvalue-reference or a non-reference.

By constrast, when you say (a + b).g() , the temporary object is used as the implicit instance argument in the member function call, which does not care about the value category. Mutable values bind to non-const and const member functions, and const values only bind to const member functions (and similarly for volatile ).

Actually, C++11 did add a way to qualify the value category of the implicit instance argument, like so:

struct Foo()
{
    Foo operator+(Foo const & lhs, Foo const & rhs);

    void g() &;     // #1, instance must be an lvalue
    void g() &&;    // #2, instance must be an rvalue
}

Foo a, b;

a.g();            // calls #1
b.g();            // calls #1
(a + b).g();      // calls #2

*) this is the case for an overloaded operator as in this example, and also for built-in binary operators. You can of course make overloaded operators which produce lvalues, though going against the common conventions would probably be considered very confusing.

Answer 2

造成混淆的原因不是无法识别临时对象，在两种情况下a+b结果都是临时对象，而是错误地假设non const方法需要左值并且不接受临时对象，这是不正确的。

Answer 3

For a simple case, think of following piece of code:

int func(int lhs, int rhs)
{
    return lhs + rhs;
}

int main() {
    int a = 1, b = 2, c = 3;
    return func(a * c, b * c);
}

Because func takes two integers, the program must calculate the values of a * c and b * c and store them somewhere -- it can't store them in a or b or c . So the resulting code is equivalent to:

int lhsParam = a * c;
int rhsParam = b * c;
return func(lhsParam, rhsParam);

Again, at the end of func() we return a calculate value, lhs + rhs . The compiler must store it in a new place.

For integers and so forth this seems very simple, but consider instead

int function(std::string filename);
function("hello");

filename has to be a std::string , but you passed a const char* . So what the compiler does is:

std::string filenameParam = "hello"; // construct a new object
function(filenameParam);

just like the previous example, but this time it is hopefully clearer that we're constructing a temporary object.

Note: The convention of calling them "somethingParam" is just for clarity in this answer.