Why copy constructor is not called in this case?

Question

Hello everybody.

Here is the little code snippet:

class A
{
public:
    A(int value) : value_(value)
    {
     cout <<"Regular constructor" <<endl;
    }

    A(const A& other) : value_(other.value_) 
    {
     cout <<"Copy constructor" <<endl;
    }

private:
    int value_;
};
int main()
{
    A a = A(5);
}

I assumed that output would be "Regular Constructor" (for RHS) followed by "Copy constructor" for LHS. So I avoided this style and always declared variable of class as A a(5);. But to my surprise in the code above copy constructor is never called (Visual C++ 2008)

Does anybody know if this behavior is a result of compiler optimization, or some documented (and portable) feature of C++? Thanks.

Answer 1

This is so called RVO.

To experiment a little try to comment out copy constructor.

Answer 2

From another comment: "So by default I should not rely on it (as it may depend on the compiler)"

No, it does not depend on the compiler, practically anyway. Any compiler worth a grain of sand won't waste time constructing an A, then copying it over.

In the standard it explicitly says that it is completely acceptable for T = x; to be equivalent to saying T(x);. (§12.8.15, pg. 211) Doing this with T(T(x)) is obviously redundant, so it removes the inner T.

To get the desired behavior, you'd force the compiler to default construct the first A:

A a;
// A is now a fully constructed object,
// so it can't call constructors again:
a = A(5);

Answer 3

Here you have copy-initialization of a from temporary A(5). Implementation allowed to skip calling copy constructor here according to C++ Standard 12.2/2.

Answer 4

A a = A(5);

This line is equivalent to

A a(5);

Despite its function-style appearance, the first line simply constructs a with the argument 5. No copying or temporaries are involved. From the C++ standard, section 12.1.11:

A functional notation type conversion (5.2.3) can be used to create new objects of its type. [ Note: The syntax looks like an explicit call of the constructor. —end note ]