How is a local variable created in functions?

Question

Lets say I have this code:

#include <iostream>
using namespace std;

class A{
public:
    A() { cout << "In normal ctor\n"; }
    A(const A& a) { cout << "In cpy ctor\n";  }
    A(A&& a) { cout << "In move ctor\n"; }
    ~A() { cout << "In dtor\n"; }
};

A func(A a) {
    return a;
}

void main(){
    A a1;
    A a2 = func(a1);
}

The output is the following:

In normal ctor
In cpy ctor
In move ctor
In dtor
In dtor
In dtor

Now I'm having trouble understanding what's happening inside the function ''func''.

When a1 is sent to the function, the function doesn't receive it byRef,but rather it ''creates'' it's own version of a1 which is 'a'.

That's why when the function ends, the object ''dies'' and it goes the the destractor.

So why doesn't it also go to the constructer in the first place? (Assuming that a local object is really created there)

Is there any copying that's happening behind the scenes?

Thanks in advance!

"So why doesn't it also go to the constructer" It does `In cpy ctor` — tkausl, Feb 12 '18 at 20:38
`but rather it "creates" it's own version`, yes, it is called copy construction and you see it in `In cpy ctor`. — freakish, Feb 12 '18 at 20:39
@tkausl but isn't the copy because of the "A a2 = func(a1)"? It's not inside the function — Martin, Feb 12 '18 at 20:39
@Martin no, this assignment is optimized as move construction, `In move ctor`. — freakish, Feb 12 '18 at 20:40
@freakish oh I see, so the copy constructor is happening because of the ''creation'' in the function? and the move is actually in the main? (because it's an RVALUE) — Martin, Feb 12 '18 at 20:43

Sergey Kalinichenko · Accepted Answer · 2018-02-12T20:52:18.773

Here is what happens (your program's printouts with explanations):

In normal ctor - This happens in A a1; of main
In cpy ctor - This happens when A a of func get initialized from a1 of main
In move ctor - This happens when a of func, a copy of a1, gets set into a2 (see copy elision in return)
In dtor - a1's copy is destroyed
In dtor - a2 is destroyed
In dtor - a1 is destroyed

I think the key thing here is to understand the role of the move constructor in creating a2. Your func returns A by value, which should get copied into a2. However, C++ compiler realizes that your program has no way of using the original value after the assignment, so it optimizes the call by invoking the move constructor.

Thank you very much! Now I see the mistake that I've had, I thought that the copy constructor happens in the main, when it actually happens in the function, so it actually DOES create the 'a'! — Martin, Feb 12 '18 at 20:59

score 3 · Answer 2 · answered Feb 12 '18 at 20:44

3

void main(){
    A a1; -- > Normal constructor
    A a2 = func(a1); --> Copy(a1 to a), Move(a to a2), destructor(a)
} -->  destructor a1, a2

That is the reason you are seeing the output in that order.

answered Feb 12 '18 at 20:44

AdityaG

428
1
3
17

score 3 · Answer 3 · answered Feb 12 '18 at 20:45

func is passed an A by copy (I.E. there is no reference and it isn't a pointer, etc.). That is why the copy constructor is called. After it is created it is moved into the position of a2, thus the move constructor. After the move, a is destroyed (because func returns and it is out of scope), and then both of a1 and a2 (because main returns).

You asked why it doesn't go into the constructor but it does. For every A you create a different constructor is called, first a1 (normally) then a in func (via copy) and then finally a2 (via move).

How is a local variable created in functions?

3 Answers3