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"));
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.
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.
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));
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.
