std :: vector :: emplace_back和std :: move

Question

Is there any advantage of using std::vector::emplace_back and std::move together? or it is just redundant since std::vector::emplace_back will do an inplace-construction?

Cases for clarification:

std::vector<std::string> bar;

First:

bar.emplace_back(std::move(std::string("some_string")));

Second:

std::string str("some_string");
bar.emplace_back(std::move(str));

Third:

bar.emplace_back(std::move("some_string"));

Answer 1

In the second version, there is an advantage. Calling emplace_back will call the move constructor of std::string when std::move is used, which could save on a copy (so long as that string isn't stored in a SSO buffer). Note that this is essentially the same as push_back in this case.

std::move in the first version is unnecessary, as the string is already a prvalue.

std::move in the third version is irrelevant, as a string literal cannot be moved from.

The simplest and most efficient method is this:

bar.emplace_back("some_string");

That requires no unnecessary std::string constructions as the literal is perfect-forwarded to the constructor.

Answer 2

emplace_back calls to somehthing like

new (data+size) T(std::forward<Args>(args)...);

if args are basic - non - rvalue-referenced std::string , the expression will compile to

new (data+size) std::string(str); //str is lvalue - calls std::string::string(const string& rhs)

meaning the copy constructor will take place. but, if you use std::move on str , the code will compile to

new (data+size) std::string(str); //str is r-value reference, calls std::string::string(string&& rhs)

so move semantics takes place. this is a huge performance gain.
do note, that str is lvalue, it has a name, so in order to create r-value-reference from it, you must use std::move .

in the example

vec.emplace_back("some literal"); 

the code will compile to

new (data+size) std::string("literal"); //calls std::string::string(const char*);

so no temporaries.

the third example is nonsense. you cannot move literals.

Answer 3

The whole idea of emplace_back is to get rid of copying and moving operations. You just need to pass input parameters of std::string into emplace_back . A std::string object will be constructed inside emplace_back method.

bar.emplace_back("some_string");

If you already have a string, it makes sense to use std::move . A std::string object will be constructed inside emplace_back by moving data from str .

std::string str("some_string");
bar.emplace_back(std::move(str));

Answer 4

There is a point of doing so in the second case. Consider this code:

int main()
{
    std::vector<std::string> bar;
    std::string str("some_string");
    bar.emplace_back(std::move(str)); str.clear();
    // bar.emplace_back(str);
    std::cout << str << std::endl;
}

If you change the comment to the line above, you can see that you will end up with two copies of "some_string" (one in bar and one in str ). So it does change something.

Otherwise, the first one is moving a temporary, and the third is moving a constant string literal. It does nothing.