Do I need to write return std :: move (local_var)?

If the type of the variable coincides with the type of the return value, then do not write T t; return std::move(t); T t; return std::move(t); .

It is necessary to write T f() { T t; return t; } T f() { T t; return t; } T f() { T t; return t; } because in return variable t is considered rvalue.
The standard C ++ 11 says:

12.8 Copying and moving class objects [class.copy] p32

When the criteria for skipping copying / moving ( copy elision , including RVO) are met (except for restrictions on the parameters of the function), and the expression denoting the object to be copied is lvalue, then the constructor is selected as if it were rvalue.

One of the cases of copy skipping is NRVO :

In return , if the function returns a class *, and the return expression is the name of a non- volatile object with an automatic storage duration (except for the function parameter or catch ), and its type is the same as the return type.

(* note: struct and union are also types-classes )

In C ++ 14 , the wording is slightly different, the case of return considered separately from the copy skipping (RVO):

When the criteria for skipping copying / moving is met [...] and the expression in return is an lvalue or id-expression (including in brackets) that denotes an object with automatic storage duration declared in the body or parameters of a function or lambda expression .

Thus, starting from C ++ 11, the standard guarantees that if the optimizer is turned off, and NRVO is not, then in the following cases the displacement constructor will be called, not copied:

 struct T { T(); T(T&&); T(const T&); }; T f() { T t; return t; // Имя локальной переменной, вызов T::T(T&&) } T f() { T t; return (t); // Имя локальной переменной в скобках, вызов T::T(T&&) } T g(T t) { return t; // Имя параметра, вызов T::T(T&&) } 

Since all that std::move(x) does is to convert an expression into a reference to an rvalue, there is no point in writing T f() { T t; return move(t); } T f() { T t; return move(t); } T f() { T t; return move(t); } . (This also takes away the possibility of NRVO).

Moreover, if the expression in return not a name, then the automatic conversion to rvalue will not work.

 T f1() { struct X { T t; } x; return xt; // Часть объекта, будет вызов T::T(const T&) // Надо написать std::move(xt) } T g1(T* pt) { return *pt; // Не имя локальной переменной или параметра, // Надо написать std::move(*pt) } 

More complicated example:

 T h1() { T a; while (...) { T b; if (...) { return b; // вызов T::T(T&&) } } return a; // вызов T::T(T&&) } T h2(T a, T b, bool c) { return c ? a : b; // Не имя локальной переменной или параметра, // надо написать std::move(с ? a : b) } 

If the variable type differs from the return type , then the rules above do not work, and you should write std::move(t) :

 struct Base { virtual ~Base() {} }; struct Derived : Base {}; std::unique_ptr<Base> f() { std::unique_ptr<Derived> r; return std::move(r); // Нужен явный move, потому что типы разные. }