# 浅谈move semantics及copy elision的一点理解

Object foo(){
    Object obj;

    return obj;
}

Object obj1;
Object obj2=obj1;   //  assume class Object have defined
                    //  copy constructor and operator=

class Object{
    Object(Object&& src){
        // 为方便起见并未考虑自赋值等其他情形
        data = src.data;    // data往往为指向对象的指针，避免拷贝
        src.data = nullptr; // “销毁”源对象(src)
    }
}

int &&rr1 = 42;     //  正确： 字面常量是右值
int &&rr2 = rr1;    //  错误： 表达式rr1是左值

template <typename T> void func(T&&);

func(42);   //  实参是一个int类型的右值；模板参数T是int
func(i);    //  调用不合法，i是左值

template <class _Ty>
typename remove_reference_t<_Ty>&& move(_Ty&& _Arg) noexcept {
    return static_cast<remove_reference_t<_Ty>&&>(_Arg);
}

std::string str("move");
std::string&& rr1 = std::move(str);     //  单纯的绑定引用，未触发移动构造，
                                        //  str内元素未被移动
std::string rr2 = std::move(str);       //  触发移动构造，str内元素被移动

template <class _Ty>
_Ty&& forward( remove_reference_t<_Ty>& _Arg ) noexcept {
    return static_cast<_Ty&&>(_Arg);
}
template <class _Ty>
_Ty&& forward( remove_reference_t<_Ty>&& _Arg ) noexcept {
    return static_cast<_Ty&&>(_Arg);
}

32 When certain criteria are met, an implementation is allowed to omit the copy/move construction of a class
object, even if the copy/move constructor and/or destructor for the object have side effects. In such cases,
the implementation treats the source and target of the omitted copy/move operation as simply two different
ways of referring to the same object, and the destruction of that object occurs at the later of the times
when the two objects would have been destroyed without the optimization.123 This elision of copy/move
operations, called copy elision, is permitted in the following circumstances (which may be combined to
eliminate multiple copies):
— in a return statement in a function with a class return type, when the expression is the name of a
non-volatile automatic object (other than a function or catch-clause parameter) with the same cvunqualified type as the function return type, the copy/move operation can be omitted by constructing
the automatic object directly into the function’s return value
— in a throw-expression, when the operand is the name of a non-volatile automatic object (other than
a function or catch-clause parameter) whose scope does not extend beyond the end of the innermost
enclosing try-block (if there is one), the copy/move operation from the operand to the exception
object (15.1) can be omitted by constructing the automatic object directly into the exception object
— when a temporary class object that has not been bound to a reference (12.2) would be copied/moved
to a class object with the same cv-unqualified type, the copy/move operation can be omitted by
constructing the temporary object directly into the target of the omitted copy/move
— when the exception-declaration of an exception handler (Clause 15) declares an object of the same type
(except for cv-qualification) as the exception object (15.1), the copy/move operation can be omitted
by treating the exception-declaration as an alias for the exception object if the meaning of the program
will be unchanged except for the execution of constructors and destructors for the object declared by
the exception-declaration.

class Thing {
public:
  Thing();
  ~Thing();
  Thing(const Thing&);
};
Thing f() {
  Thing t;
  return t;
}

Thing t2 = f();

Here the criteria for elision can be combined to eliminate two calls to the copy constructor of class Thing:
the copying of the local automatic object t into the temporary object for the return value of function f()
and the copying of that temporary object into object t2. Effectively, the construction of the local object
t can be viewed as directly initializing the global object t2, and that object’s destruction will occur at
program exit. Adding a move constructor to Thing has the same effect, but it is the move construction from
the temporary object to t2 that is elided. — end example ]

Thing temp_t = t;

Thing t2 = temp_t;

class Thing {
public:
  Thing(){
      std::cout << "constructor." << std::endl;
  }
  ~Thing(){
      std::cout << "destructor." << std::endl;
  }
  Thing(const Thing&){
      std::cout << "copy constructor." << std::endl;
  }
};

constructor.    # t2.constructor
destructor.     # main() ends, t2.destrctor

Thing f(int n) {
  Thing t, t1;
  if(n > 10){
      return t;
  }
  else{
      return t1;
  }
}

Thing t2 = f(1);

constructor.    # t and t1
constructor.    # constructor
copy constructor.   # temp_t = t or t1, ' t2 = temp_t ' is optimized
destructor.     # t and t1
destructor.     # destructor
destructor.     # main() ends, t2.destructor