C++11 标准新特性 右值引用与转移语义 -2

look_w

实现转移构造函数和转移赋值函数以一个简单的 string 类为示例，实现拷贝构造函数和拷贝赋值操作符。
示例程序 :

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46

class MyString { private: char* _data; size_t   _len; void _init_data(const char *s) {    _data = new char[_len+1];    memcpy(_data, s, _len);    _data[_len] = '\0'; } public: MyString() {    _data = NULL;    _len = 0; } MyString(const char* p) {    _len = strlen (p);    _init_data(p); } MyString(const MyString& str) {    _len = str._len;    _init_data(str._data);    std::cout << "Copy Constructor is called! source: " << str._data << std::endl; } MyString& operator=(const MyString& str) {    if (this != &str) {      _len = str._len;      _init_data(str._data);    }    std::cout << "Copy Assignment is called! source: " << str._data << std::endl;    return *this; } virtual ~MyString() {    if (_data) free(_data); } }; int main() { MyString a; a = MyString("Hello"); std::vector<MyString> vec; vec.push_back(MyString("World")); }

运行结果 :

1 2	Copy Assignment is called! source: Hello Copy Constructor is called! source: World

这个 string 类已经基本满足我们演示的需要。在 main 函数中，实现了调用拷贝构造函数的操作和拷贝赋值操作符的操作。MyString(“Hello”) 和 MyString(“World”) 都是临时对象，也就是右值。虽然它们是临时的，但程序仍然调用了拷贝构造和拷贝赋值，造成了没有意义的资源申请和释放的操作。如果能够直接使用临时对象已经申请的资源，既能节省资源，有能节省资源申请和释放的时间。这正是定义转移语义的目的。
我们先定义转移构造函数。

1 2 3 4 5 6 7

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; }

和拷贝构造函数类似，有几点需要注意：
1. 参数（右值）的符号必须是右值引用符号，即“&&”。
2. 参数（右值）不可以是常量，因为我们需要修改右值。
3. 参数（右值）的资源链接和标记必须修改。否则，右值的析构函数就会释放资源。转移到新对象的资源也就无效了。
现在我们定义转移赋值操作符。

1 2 3 4 5 6 7 8 9 10

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

这里需要注意的问题和转移构造函数是一样的。
增加了转移构造函数和转移复制操作符后，我们的程序运行结果为 :

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

由此看出，编译器区分了左值和右值，对右值调用了转移构造函数和转移赋值操作符。节省了资源，提高了程序运行的效率。
有了右值引用和转移语义，我们在设计和实现类时，对于需要动态申请大量资源的类，应该设计转移构造函数和转移赋值函数，以提高应用程序的效率。
标准库函数 std::move既然编译器只对右值引用才能调用转移构造函数和转移赋值函数，而所有命名对象都只能是左值引用，如果已知一个命名对象不再被使用而想对它调用转移构造函数和转移赋值函数，也就是把一个左值引用当做右值引用来使用，怎么做呢？标准库提供了函数 std::move，这个函数以非常简单的方式将左值引用转换为右值引用。
示例程序 :

1 2 3 4 5 6 7 8 9 10 11 12 13

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)); }

运行结果 :

1 2	LValue processed: 0 RValue processed: 0

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

1 2 3 4 5 6

template <class T> 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 函数的定义变为 :

1 2 3 4 5 6

template <class T> 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 的定义为：

1 2 3 4 5 6

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

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

1 2 3 4 5

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

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

1 2 3

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

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

1 2 3 4 5

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

C++11 中定义的 T&& 的推导规则为：
右值实参为右值引用，左值实参仍然为左值引用。
一句话，就是参数的属性不变。这样也就完美的实现了参数的完整传递。
右值引用，表面上看只是增加了一个引用符号，但它对 C++ 软件设计和类库的设计有非常大的影响。它既能简化代码，又能提高程序运行效率。每一个 C++ 软件设计师和程序员都应该理解并能够应用它。我们在设计类的时候如果有动态申请的资源，也应该设计转移构造函数和转移拷贝函数。在设计类库时，还应该考虑 std::move 的使用场景并积极使用它。
总结右值引用和转移语义是 C++ 新标准中的一个重要特性。每一个专业的 C++ 开发人员都应该掌握并应用到实际项目中。在有机会重构代码时，也应该思考是否可以应用新也行。在使用之前，需要检查一下编译器的支持情况。