Can move constructor take arguments other than the class itself?

Question

Basically, the argument of the move constructor is the class itself.

However, if I want to construct an object of the class from a lvalue without copy operation can I do like this?

class A{
   A(const LargeDataType& inData):data(inData) {} // constructor 1
   A(LargeDataType&& inData):data(std::move(inData)) {} // constructor 2
   private:
        LargeDataType data;
};

To use it:

Method 1:

LargeDataType outData = 100;
A objA(std::move(outData)); // call constructor 2

Method 2 (If constructor 2 was not implemented):

LargeDataType outData = 100;
A objA(std::move(outData)); // call constructor 1

In this way, there is no copy operation when constructing the objA. My questions are:

Is this legal to create a move constructor like this?
This is more efficient than traditional constructor because no copy needed during objA creation?
Whether method 2 could be better and has the same efficiency as the method 1?

Thanks a lot!

You aren't avoiding any copies with these shenanigans, because "moving" and `int` is the same as copying it. — juanchopanza, Apr 18 '17 at 20:06
`int` does not have a move constructor or any move operations, so this all just becomes copies... — Chris Dodd, Apr 18 '17 at 20:06
For `int`, it is not really useful, but might be useful for `std::string` or `std::vector` for example. — Jarod42, Apr 18 '17 at 20:06
@Jarod42 yes, this is just an example, I want to use this for more complicated data types — lightrek, Apr 18 '17 at 20:07
You can certainly write a constructor like that, and doing so can even have benefits. But it is not a move constructor. — Benjamin Lindley, Apr 18 '17 at 20:07
@lightrek Well, you should try not to simplify away things that actually matter. — juanchopanza, Apr 18 '17 at 20:08
@BenjaminLindley will this kind of rvalue reference constructor more efficient than lvalue reference constructor? — lightrek, Apr 18 '17 at 20:09
If the type being passed in is cheaper to move than it is to copy, yes. — Benjamin Lindley, Apr 18 '17 at 20:10
You might be interested in this: http://stackoverflow.com/questions/16724657/why-do-we-copy-then-move — Benjamin Lindley, Apr 18 '17 at 20:13

R Sahu · Accepted Answer · 2017-04-18T20:47:07.843

2

What you have is not a move constructor. It is just a constructor that takes rvalue references as arguments. The are perfectly fine constructors but they are not move constructors.

From the C++11 Standard (12.8/3):

A non-template constructor for class X is a move constructor if its first parameter is of type X&&, const X&&, volatile X&&, or const volatile X&&, and either there are no other parameters or else all other parameters have default arguments (8.3.6).

Only

A(A&& a) { ... }
A(const A&& a) { ... }
A(volatile A&& a) { ... }
A(volatile const A&& a) { ... }

maybe called move constructors.

If you have parameters with default values in addition to the above, they also qualify as move constructors. E.g.

A(A&& a, T arg = {}) { ... }

edited Apr 18 '17 at 20:47

answered Apr 18 '17 at 20:09

R Sahu

204,454
14
159
270

A move constructor can have more signatures than the one in your example. – juanchopanza Apr 18 '17 at 20:10
`A(const A&&)` would also be a move constructor ;-) – Jarod42 Apr 18 '17 at 20:10
Even `A(volatile A&&)` – juanchopanza Apr 18 '17 at 20:10
2

Still not complete :) `A(A&&, T = {})` and so on would also be move constructors. The additional parameters must all have default arguments. – Praetorian Apr 18 '17 at 20:13
As a purely colloquial matter, sometimes people call `Foo(Bar&&);` a "converting move constructor". Language-lawyers will undoubtedly point out that that terminology doesn't make much sense. – T.C. Apr 18 '17 at 22:31

Can move constructor take arguments other than the class itself?

1 Answers1