我应该总是在构造函数中使用 std::move 吗？

Question

Are the move semantics used in Example A necessary, and which struct is superior?

Example A:

struct A
{
    std::string a;
    A( std::string a ) : a( std::move(a) ){ }
};

Example B:

struct B
{
    std::string b;
    B( const std::string& b ) : b( b ){ }
};

I don't believe this is a duplicate question. I am asking specifically which example is superior from the perspective of using member initialization in a class constructor. None of the examples or answers listed in the other question dealt with member initialization.

I don't like that the constructor is called with a reference parameter, then copied into the member. It seems that it could be wasteful to have multiple copy operations.

I want to "pipe" the data into the members as efficiently as possible but I don't want to take rvalues as the constructor parameters.

Answer 1

Struct A is superior.

Moving an object is usually very cheap (and can often be completely optimized out), so typically one shouldn't care about the number of moves. But it's important to minimize the number of copies. The number of copies in example A is equal to or less than the number of copies in example B.

More specifically, A and B are equivalent if the original string is an L-value:

std::string s;
...
A a(s);  // one copy
B b(s);  // one copy

but A is better when the original string is an R-value:

std::string MakeString();
...
A a(MakeString());  // zero copies
B b(MakeString());  // one copy

Answer 2

In my opinion it is not genuine to compare both.

Most of the times the implemented copy constructor makes deep copy and the main intention behind is to ensure the source object is not modified.

std::move which eventually calls move constructor for rvalue reference, just copies the pointer and can set the source object pointer to NULL. This scenario is mainly for temporary objects .

So both examples are meant for two different purpose , one (copy constructor) when you want source object to be untouched, and the other (std::move) is meant for dealing temporary objects.