output：

Move Assignment is called! source: Hello 
Move Constructor is called! source: World

注意新添加的两个函数：

    MyString(MyString&& str) {
        std::cout << "Move Constructor is called! source: " << str._data << std::endl;
        _len = str._len;
        _data = str._data;
        str._len = 0;
        str._data = NULL;
    }
    MyString& operator=(MyString&& str) {
        std::cout << "Move Assignment is called! source: " << str._data << std::endl;
        if (this != &str) {
            clear();
            _len = str._len;
            _data = str._data;
            str._len = 0;
            str._data = NULL;
        } 
        return *this; 
    }

和拷贝构造函数类似，有几点需要注意：

观察其源码，我们可以不难发现，实际上就是转移资源（指针），从而避免了临时对象的复制。

由此看出，编译器区分了左值和右值，对右值调用了转移构造函数和转移赋值操作符。节省了资源，提高了程序运行的效率。

有了右值引用和转移语义，我们在设计和实现类时，对于需要动态申请大量资源的类，应该设计转移构造函数和转移赋值函数，以提高应用程序的效率。

此处补充一点关于拷贝构造函数的小知识：
如果我们在main函数里面写下以下语句时：

MyString a(MyString("Hello")); 

什么都不会输出。为什么呢？

原来，在C++中，下面三种对象才需要调用拷贝构造函数（有时也称“复制构造函数”）：

此处用到了3）的道理。

但如果你写下：

MyString a(move(MyString("Hello"))); 

编译器会调用转移拷贝构造函数。因为move返回了一个右值引用。

标准库函数std::move

move的源码：

void move(basic_ios&& __rhs) {
    move(__rhs);
}
basic_ios<_CharT, _Traits>::move(basic_ios& __rhs) {
    ios_base::move(__rhs);
    __tie_ = __rhs.__tie_;
    __rhs.__tie_ = 0;
    __fill_ = __rhs.__fill_;
}

由于标准库其他相当复杂的内容不在本文的讨论范围，所以不share出来，我们大概分析move源码可以看出来，实际上就是把一个右值的指针传给了左值，然后右值的指针指向空。实现了交换指针。

由于编译器只对右值引用才能调用转移构造函数和转移赋值函数，而所有命名对象都只能是左值引用，如果已知一个命名对象不再被使用而想对它调用转移构造函数和转移赋值函数，也就是把一个左值引用当做右值引用来使用，怎么做呢？标准库提供了函数 std::move，这个函数以非常简单的方式将左值引用转换为右值引用。

 void ProcessValue(int& i) { 
  std::cout << "LValue processed: " << i << std::endl; 
 } 

 void ProcessValue(int&& i) { 
  std::cout << "RValue processed: " << i << std::endl; 
 } 

 int main() { 
  int a = 0; 
  ProcessValue(a); 
  ProcessValue(std::move(a)); 
 }
/* output:
 LValue processed: 0 
 RValue processed: 0
*/

std::move在提高 swap 函数的的性能上非常有帮助，一般来说，swap函数的通用定义如下：

template 
   
     swap(T& a, T& b) { T tmp(a); // copy a to tmp a = b; // copy b to a b = tmp; // copy tmp to b } 
   

有了 std::move，swap 函数的定义变为 :

template 
   
     swap(T& a, T& b) { T tmp(std::move(a)); // move a to tmp a = std::move(b); // move b to a b = std::move(tmp); // move tmp to b } 
   

通过 std::move，一个简单的 swap 函数就避免了 3 次不必要的拷贝操作。

精确传递 (Perfect Forwarding)

本文采用精确传递表达这个意思。”Perfect Forwarding”也被翻译成完美转发，精准转发等，说的都是一个意思。

精确传递适用于这样的场景：需要将一组参数原封不动的传递给另一个函数。

“原封不动”不仅仅是参数的值不变，在 C++ 中，除了参数值之外，还有一下两组属性：左值／右值和 const/non-const。 精确传递就是在参数传递过程中，所有这些属性和参数值都不能改变。在泛型函数中，这样的需求非常普遍。

下面举例说明。函数 forward_value 是一个泛型函数，它将一个参数传递给另一个函数 process_value。
forward_value 的定义为：

 template 
   
     void forward_value(const T& val) { process_value(val); } template 
    
      void forward_value(T& val) { process_value(val); }
    
   

函数 forward_value 为每一个参数必须重载两种类型，T& 和 const T&，否则，下面四种不同类型参数的调用中就不能同时满足:

  int a = 0; 
  const int &b = 1; 
  forward_value(a); // int& 
  forward_value(b); // const int& 
  forward_value(2); //  const int&

对于一个参数就要重载两次，也就是说如果函数有n个参数，就要重载2^n。这个函数的定义次数对于程序员来说，是非常低效的。我们看看右值引用如何帮助我们解决这个问题:

template 
   
     void forward_value(T&& val) { process_value(val); }
   

只需要定义一次，接受一个右值引用的参数，就能够将所有的参数类型原封不动的传递给目标函数。四种不用类型参数的调用都能满足，参数的左右值属性和 const/non-cosnt 属性完全传递给目标函数 process_value。这个解决方案不是简洁优雅吗？

  int a = 0; 
  const int &b = 1; 
  forward_value(a); // int& 
  forward_value(b); // const int& 
  forward_value(2); // const int&&

C++11 中定义的 T&& 的推导规则为：

右值实参为右值引用，左值实参仍然为左值引用。

一句话，就是参数的属性不变。这样也就完美的实现了参数的完整传递。
右值引用，表面上看只是增加了一个引用符号，但它对 C++ 软件设计和类库的设计有非常大的影响。它既能简化代码，又能提高程序运行效率。每一个 C++ 软件设计师和程序员都应该理解并能够应用它。我们在设计类的时候如果有动态申请的资源，也应该设计转移构造函数和转移拷贝函数。在设计类库时，还应该考虑 std::move 的使用场景并积极使用它。

测试程序