Will I get a copy or assignment with this initialization?

Question

Compare these two initialization methods in C++ for a trivial complex number class.

complx one(1,3);
complx two = complx(3,4);

In the second case, will I get a constructor followed by an assignment, followed by a copy, or just the constructor?

Is it possible to distinguish the two types of initializations ?

Did you override the default assignment operator or copy constructor? — Andrew White, Mar 14 '13 at 15:03
It would surprise me if this hasn't been asked many times before. — NPE, Mar 14 '13 at 15:04
Joachim: because if I do, I will just learn how it works. If I post, I will also learn plenty of keywords to learn C++ in more detail — Stefano Borini, Mar 14 '13 at 15:04
@JoachimPileborg If you override those methods you can effect the default behavior I believe. I might be wrong but the optimizer treats the default cases "specially" — Andrew White, Mar 14 '13 at 15:05
possible duplicate of [Copy constructors and Assignment Operators](http://stackoverflow.com/questions/2027873/copy-constructors-and-assignment-operators) — Bo Persson, Mar 14 '13 at 15:21

Joseph Mansfield · Accepted Answer · 2013-03-14T15:24:15.760

complx two = complx(3,4);

This is a copy-initialization. The particular semantics for this initializer are covered by this rule:

If the initialization is direct-initialization, or if it is copy-initialization where the cv-unqualified version of the source type is the same class as [...] the class of the destination, constructors are considered. The applicable constructors are enumerated (13.3.1.3), and the best one is chosen through overload resolution (13.3). The constructor so selected is called to initialize the object, with the initializer expression or expression-list as its argument(s). [...]

That is, a copy-initialization where the source type is the same as the destination type behaves like a direct-initialization. So that makes the declaration equivalent to:

complx two(complx(3,4));

This constructs a temporary complx object and then uses the copy/move constructor to construct two.

However, this copy/move may be elided:

when a temporary class object that has not been bound to a reference (12.2) would be copied/moved to a class object with the same cv-unqualified type, the copy/move operation can be omitted by constructing the temporary object directly into the target of the omitted copy/move

However, the copy constructor must still be accessible, as though it were being called.

Can the two initializations be distinguished? Assuming the copy/move is valid, not reliably, no. If the compiler does elide the copy in the copy-initialization or if the copy is well behaved and doesn't have any extra side effects, then both will behave exactly the same. If it does not elide the copy and the copy has some extra side effects, then you will notice a difference.

The two can be reliably distinguished by implementing a `move constructor` for `complx`. You should remove that statement or at least clarify they are not distinguishable in versions of C++ older than c++11 — Ed Rowlett-Barbu, Mar 14 '13 at 15:13
@Tribse that is not correct. Classes such as `std::unique_ptr` which rely on move semantics would work if that was correct. — Ed Rowlett-Barbu, Mar 14 '13 at 15:16
You can distinguish between the two in a simple way that second cannot compile without a copy constructor being available and accessible. — Alok Save, Mar 14 '13 at 15:16

Alok Save · Answer 2 · 2013-03-14T15:14:33.913

3

First is known as Direct Initialization.
It simply calls the best match constructor.

Second case is known as Copy initialization.
it creates a object of type Complx and then copies that object to create the two object.
so it involves call to the constructor followed by a copy constructor call.

The compilers are allowed to elide the copy constructor call in general whenever they can(there are special conditions, the code example meet those conditions). But none of the optimizations are guaranteed and they depend on the efficiency of the compiler implementation so the copy constructor needs to be available for second example to compile.

Is it possible to distinguish the two types of initializations ?

Yes, second example will not compile unless a copy constructor is available and accessible.

Good Read:

GotW #36: Initialization

edited Mar 14 '13 at 15:14

answered Mar 14 '13 at 15:04

Alok Save

202,538
53
430
533

Is this true for *all* cases? I thought the default case was "special" and the assignment could be optimized away – Andrew White Mar 14 '13 at 15:07
1

@AndrewWhite there is no assignment. There is a copy construction, but the copy can be elided. – juanchopanza Mar 14 '13 at 15:09
1

@AndrewWhite: There is no assignment involved. Th copy constructor call can be elided but that is not guaranteed and the copy constructor needs to be available. – Alok Save Mar 14 '13 at 15:09
Thanks, sorry misquoted there. – Andrew White Mar 14 '13 at 15:12

Ed Rowlett-Barbu · Answer 3 · 2013-03-14T15:20:40.243

0

In C++ you can distinguish the two types of initializations by implementing a move constructor or a copy constructor like this

struct complx

{
  complx(complx && aOther){} // <- move constructor (C++11)
  complx(const complx & aOther){} // <- copy constructor (C++03)
  complx(float a, float b) {} // <- normal constructor
};

Your first line of code will call the normal constructor. Your second line of code is called copy initialization with an rvalue, and will call the move constructor in C++11 and the copy constructor in C++03. Note that in C++03, complx(complx && aOther){} is not recognized (invalid syntax), and should be removed.

edited Mar 14 '13 at 15:20

answered Mar 14 '13 at 15:03

Ed Rowlett-Barbu

1,611
10
27

This constructor `complx(complx && aOther){}` is called a `move constructor`. It gets called only when you try to create a `complx` object from another, temporary one like `complx(3,4)` in your example. – Ed Rowlett-Barbu Mar 14 '13 at 15:07
`&&` is called an `rvalue reference`, and temporary objects like `complx(3,4)` match it. A good starting point is to read the following SO question to learn more about them: http://stackoverflow.com/questions/3106110/what-are-move-semantics – Ed Rowlett-Barbu Mar 14 '13 at 15:09
@Zadirion: sorry, I was wrong, that is not a typo, that is part of C++11 which I am not as familiar with. – Andrew White Mar 14 '13 at 15:10

Will I get a copy or assignment with this initialization?

3 Answers3