Copy Constructor?

Question

Possible Duplicate:
Why copy constructor is not called in this case?

When you pass an object to a function by value or return an object from a function by value, the copy constructor must be called. However, in some compilers this does not happen? Any explanation?

To those voting to close: this is programming-related. It's also a duplicate: http://stackoverflow.com/questions/1758142/why-copy-constructor-is-not-called-in-this-case is one such question, and there may be other dupes. — David Thornley, Feb 24 '10 at 20:57
@David Thornley, that question is related but I don't think the OP will find what he wants there. — Michael Kristofik, Feb 24 '10 at 21:01
@Kristo: As far as I can tell from the question, it is. I suppose I could have interpreted the question more loosely, then voted to close as "not a real question". — David Thornley, Feb 24 '10 at 21:20

score 5 · Answer 1 · answered Feb 24 '10 at 20:52

5

I assume they are referring to return-value optimization implemented in many compilers where the code:

CThing DoSomething();

gets turned into

void DoSomething(CThing& thing);

with thing being declared on the stack and passed in to DoSomething:

CThing thing;
DoSomething(thing);

which prevents CThing from needing to be copied.

answered Feb 24 '10 at 20:52

Doug T.

64,223
27
138
202

It's even better than that. The compiler is allowed to construct a `CThing` directly in the return statement of `DoSomething`, avoiding the overhead altogether. – Michael Kristofik Feb 24 '10 at 21:26

score 5 · Answer 2 · answered Feb 24 '10 at 20:54

It often doesn't happen because it doesn't need to happen. This is called copy elision. In many cases, the function doesn't need to make copies, so the compiler optimizes them away. For example, with the following function:

big_type foo(big_type bar)
{
  return bar + 1;
}

big_type a = foo(b);

Will get converted to something like:

void foo(const big_type& bar, big_type& out)
{
  out = bar + 1;
}

big_type a;
foo(b, a);

The removal of the return value is called the "Return Value Optimization" (RVO), and is implemented by most compilers, even when optimizations are turned off!

This isn't exactly correct. In your first code snippet the compiler may construct `a` directly inside the `return` statement. It doesn't have the overhead of constructing a default `big_type` as your second code example implies. — Michael Kristofik, Feb 24 '10 at 21:05

Michael Kristofik · Answer 3 · 2010-02-24T21:35:36.463

The compiler may call the copy constructor for pass-by-value or return-by-value, but it doesn't have to. The standard allows for optimizing it away (in standardese it's called copy elision) and in practice many compilers will do so, even if you don't have optimizations turned on. The explanation is pretty detailed, so I'll point you at C++ FAQ LITE.

Short version:

struct Foo
{
    int a, b;
    Foo(int A, int B) : a(A), b(B) {}
};

Foo make_me_a_foo(int x)
{
    // ...blah, blah blah...
    return Foo(x, x+1);  // (1)
}

Foo bar = make_me_a_foo(42);  // (2)

The trick here is the compiler is allowed to construct bar from line (2) directly in line (1) without incurring any overhead of constructing temporary Foo objects.

Copy Constructor?

3 Answers3