Should I always use std::move in a constructor?

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