If I move a local object into a function, will it still be valid afterward?

Question

So, this provides the intended output:

void f(std::string&& s)
{
   s += " plus extra";
}

int main(void)
{
   std::string str = "A string";
   f( std::move(str) );
   std::cout << str << std::endl;

   return 0;
}

A string plus extra

That is, it works when I run it on Ideone, but is it UB? Adding extra string initializations before and after the call to f didn't change anything.

Answer 1

It is valid, not UB.

It is also horribly obfuscated code. std::move(s) is nothing but a cast to rvalue. By itself it does not actually generate any code at all. Its only purpose is to turn an lvalue into an rvalue so that client code can overload on lvalue/rvalue expressions (of string in this case).

You should pass by lvalue-reference for this case:

void f(std::string& s)
{
   s += " plus extra";
}
...
f( str );

Or alternatively, pass by value and return a new string:

std::string f(std::string s)
{
   s += " plus extra";
   return s;
}
...
str = f( std::move(str) );

Answer 2

std::move doesn't move anything. It indicates that an object may be "moved from", by casting its argument to an rvalue.

Your code is valid and there is no move operation performed.

You would get the behavior where the state of str is unspecified after calling f(), if you move-construct another string object from s. The move-constructor performs the actual move operation.

Example:

std::vector<std::string> sv;

void f(std::string&& s)
{
    s += " plus extra";
    sv.push_back(std::move(s));         // move s (str) into a new object
}

int main(void)
{
   std::string str = "A string";
   f(std::move(str));                 
   std::cout << str << std::endl;       // output: empty string
   std::cout << sv.back() << std::endl; // output: "A string plus extra"

   return 0;
}