探索C++0x: 3. 右值引用(rvalue reference)

简介

C++0x中引入了右值引用(rvalue reference)这个设施，形如T&&，用来实现移动语义(move semantics)和完美转发(perfect forwarding)。此前C++中有一个著名的性能问题——复制临时对象，由于右值引用的引入，该问题将得到极大的改善。

虽然右值引用的引入是一个很了不起的进步，也是一个明智的决定，但它并不那么讨人喜欢，至少我觉得如此。原因有二：首先是其概念本身就不容易理解，增加了一些智力负担；另外如果想享受它带来的性能好处，还必须增加一些编码工作量。

什么是左值和右值

我们首先需要熟悉一下现行C++98/03标准中，左值和右值的概念。网上现在充斥着很多对它们的解释，长篇大论的有，只言片语的也有，而且不一定清晰正确，可谓良莠不齐，这里我希望能够尽量简单准确地进行说明。

这里有两个问题经常令人混淆，必须首先澄清一下：

1. lvalue(left value)和rvalue(right value)的概念经过了长时间的演化，早已名不副实，千万不要把L和R当做真正的左右来理解。最早或许left value意味着在等号左边，right value意味着在等号右边，但对于现代C++这么复杂的语法来说，早就不适用了。
2. 左值还是右值，是针对某个表达式而言的，而不是针对某个具体值或者对象本身而言。C++ 03 标准 3.10/1 节：“每一个表达式要么是一个lvalue，要么就是一个rvalue。”因此不要单纯的考虑数字1是左值还是右值，或者存在地址0x100000上的那个string对象到底是左值还是右值，重要的是看表达式。

左值和右值的定义和判断：

如果一个语句结束的时候，该表达式代表的对象立刻被销毁，则为右值，否则就是左值。也就是说右值代表的是临时对象或者字面值，而左值则不是临时对象。引申出来的另一个判断方法是：具名的表达式意味着是左值，非具名的则为右值（非具名左值引用是个例外，它是左值）。示例代码如下：

int add(int v1, int v2)
{
    return v1 + v2;
}

int& g()
{
    static int i = 100;
    return i;
}

void example()
{
    int x = add(1, 2);  // x是左值，add(1, 2)的返回值是右值，x拷贝了它。
                        // x是持久的，具名的；
                        // add(1, 2)的返回值是临时的，非具名的。
                        // 另外这里字面值1和2也都是右值，临时的，非具名的。
    ++x;                // ++x是左值，它表示的x本身，是持久的，具名的
    x++;                // x++是右值，它表示x的原值，是临时的，非具名的
    g();                // g()是左值，虽然返回值是非具名的，但是左值引用
}

 

现行C++标准对右值的限制：

由于临时对象在语句结束后被立刻销毁，因此在语句结束后还使用它是不安全的。所以现行C++标准中，规定右值是不能被具名引用的，因为一旦被引用了就可能被使用。但令人不爽的是，由于函数在传递参数时，又需要让临时对象可以被作为实参传递，C++标准只好又规定右值可以被具名引用，但只能被常量引用，而不能被被非常量引用，且被常量引用时，如果该常量引用是具名的（也就是左值），则该临时对象的生命周期延长到和该常量引用相同。其实这个规定挺搞笑的，完全可以不用区分是否是常量，同样规定右值也可以被非常量引用，不过标准既然这么说了，那编译器就只好这么办（其实VC的某些版本没这么干）。这里要注意的是，左值一旦被具名引用，则变成了右值。示例代码如下：

int add(int v1, int v2)
{
    return v1 + v2;
}

void example()
{
    int const& x1 = add(1, 2);  // 正确，按照C++现行标准，右值可以被绑定到常量引用
                                // 不过一旦绑定到具名引用，则成为左值，这里x1就是左值
#if _SHOW_ERROR_CASE
    int& y1 = add(3, 4);        // 错误，按照C++现行标准，右值不能被绑定到非常量引用
#endif
}

 

为什么要引入右值引用？

了解临时对象造成的性能问题，了解RVO

在现行的C++标准中，如果函数返回一个对象，则该对象是一个临时对象，也就是一个右值。这就带来一个很头痛的性能问题，就是该对象会被白白的拷贝好几遍。这种纯粹浪费性能的行为完全违背了C++的设计哲学，因此现行C++标准中，不惜破坏原来简单的拷贝语义，提出可以在拷贝构造的情况下省略掉多余的拷贝，这就是著名的RVO(Return Value Optimization)。但是很多时候，RVO都不能完全奏效，性能浪费依然不能避免。示例代码如下：

// 一个简单的整型数组类，仅供示例，并非最佳设计
class int_array
{
public:

    ~int_array()    // 析构函数
    {
        cout << "  int_array::~int_array()" << endl;
        free_memory();
    }

    int_array() // 默认构造函数
    {
        cout << "  int_array::int_array()" << endl;
        alloc_memory(0);
    }

    int_array(int_array const& src) // 拷贝构造函数
    {
        cout << "  int_array::int_array(int_array const&)" << endl;
        alloc_memory(src.m_size);
        memcpy(m_buffer, src.m_buffer, m_size * sizeof(int));
    }

    int_array(unsigned int size)   // 用来初始化为0值的构造函数
    {
        cout << "  int_array::int_array(unsigned int)" << endl;
        alloc_memory(size);
        memset(m_buffer, 0, size * sizeof(int));
    }

    int_array& operator=(int_array const& rhs)  // 赋值操作符
    {
        cout << "  int_array& int_array::operator=(int_array const&)" << endl;
        if (this != &rhs)
        {
            free_memory();
            alloc_memory(rhs.m_size);
            memcpy(m_buffer, rhs.m_buffer, m_size * sizeof(int));
        }
        return *this;
    }

    unsigned int size() const   // 获取大小
    {
        return m_size;
    }

    int get_at(unsigned int offset) const   // 获取指定位置的值
    {
        return m_buffer[offset];
    }

    void set_at(unsigned int offset, int value) // 设置指定位置的值
    {
        m_buffer[offset] = value;
    }

private:

    void alloc_memory(unsigned int size)    // 分配内存
    {
        cout << "    int_array::alloc_memory(unsinged int)" << endl;
        m_buffer = new int[size];
        m_size = size;
    }

    void free_memory()  // 释放内存
    {
        cout << "    int_array::free_memory()" << endl;
        delete[] m_buffer;
    }

    int* m_buffer;
    unsigned int m_size;
};

// 生成一个有两个元素的int_arry
int_array make_int_array2(int v1, int v2)
{
    int_array result(2);    // 调用构造函数
    result.set_at(0, v1);
    result.set_at(1, v2);
    return result;          // 调用拷贝构造函数，但可以被RVO
}

// 生成一个有size个元素的int_arry
int_array make_int_array(unsigned int size, ...)
{
    if (size > 10000000)    // 如果太大则返回一个空的
        return int_array(); // 调用构造函数和拷贝构造函数

    int_array result(size); // 调用构造函数
    va_list args;
    va_start(args, size);
    for (unsigned int i = 0; i < size; ++i)
    {
        int v = va_arg(args, int);
        result.set_at(i, v);
    }
    return result;          // 调用拷贝构造函数，
                            // 两个不同的return导致RVO失败
}

void example()
{
    cout << endl << "enter" << endl;

    cout << endl << "step1" << endl;

    // 可以RVO，仅调用一次构造函数，否则按照原始语义，应该有三次构造
    int_array ia1 = make_int_array2(10, 20);

    cout << endl << "step2" << endl;

    // 无法完全RVO，调用一次构造函数，一次赋值操作，浪费一次内存分配和释放
    ia1 = make_int_array2(100, 200);

    cout << endl << "step3" << endl;

    // 无法完全RVO，调用两次构造函数，浪费一次内存分配和释放
    int_array ia2 = make_int_array(5, 1, 2, 3, 4, 5);

    cout << endl << "step4" << endl;

    // 无法RVO，调用两次次构造函数，一次赋值操作，浪费两次内存分配和释放
    ia2 = make_int_array(3, 1, 2, 3);

    cout << endl << "exit" << endl;
}

 

右值引用是救星：

为了解决这个问题，有一个很直观的方案，就是对临时对象的内部的数据（如上例中的m_buffer成员）进行操作，将它们“移动”或者“交换”过来，从而取代拷贝行为，因为反正临时对象马上就要销毁的，移动过来岂不正好？

但问题来了，如果要对临时对象的内部数据进行修改，至少需要具备两个条件：一个是需要引用临时对象，否则怎么有机会修改它呢；另一个是要识别对象是不是一个临时对象，改错了可就完蛋了。

如果简单的规定右值可以被引用，而且可以被非常量的引用，貌似可以解决第一个问题，但第二个问题还是没法解决，因为你不知道一个非常量的引用到底是不是临时对象。

因此C++0x标准中引入了右值引用，用两个连续的“&”符号来表示，和左值引用以示区别。例如int&&就表示一个整型的右值引用，而int&则还是和原来一样，表示整型的左值引用。C++0x标准进一步规定，除了原来规定的右值可以绑定到常量左值引用外，右值还可以绑定到右值引用，当然一旦被具名引用，右值还是会变成左值。而且遇到重载时，优先考虑将右值绑定到右值引用而不是左值引用（那当然，否则这玩意儿就废了）。另外，左值不允许绑定到右值引用，除非强制类型转换，这一点也很重要，以免无意中将非临时对象的内部数据给移走了。示例代码如下：

int add(int v1, int v2)
{
    return v1 + v2;
}

int const add_const(int v1, int v2)
{
    return v1 + v2;
}

void func(int& i)
{
    cout << "func(int&)" << endl;
}

void func(int const& i)
{
    cout << "func(int const&)" << endl;
}

void func(int&& i)
{
    cout << "func(int&&)" << endl;
}

void func(int const&& i)
{
    cout << "func(int const&&)" << endl;
}

template <typename T>
void f1(T&&)
{
}

void example()
{
    int x1 = 1;                     // 正确，右值可以拷贝到左值
    int& x2 = x1;                   // 正确，左值可以绑定到左值引用
    int const& x3 = x1;             // 正确，非常量左值可以绑定到常量左值引用
    int const& x4 = add(1, 2);      // 正确，右值可以被绑定到常量左值引用
    int&& x5 = add(1, 2);           // 正确，右值可以被绑定到右值引用
    int const&& x6 = add_const(1, 2); // 正确，常量右值可以被绑定到常量右值引用
    int const&& x7 = add(1, 2);     // 正确，非常量右值可以被绑定到常量右值引用
    int& x8 = x5;                   // 正确，左值可以绑定到左值引用，x5虽然是右值引用
                                    // 但由于已经是具名引用，因此变成了左值

    func(x1);                       // 调用func(int&)
    func(x3);                       // 调用func(int const&)
    func(add(1, 2));                // 调用func(int&&)
    func(add_const(1, 2));          // 应调用func(int const&&)，add_const是常量右值，
                                    // 但GCC4.5有bug，调用func(int&&)，VC10是正确的
    func(1);                        // 调用func(int&&), 字面值1被当做非常量右值
    func(x5);                       // 调用func(int&)，x5虽然是右值引用
                                    // 但由于已经是具名引用，因此变成了左值
    f1(x1);                         // 对于函数模板的推导，C++0x引入了reference collapsing，
                                    // 并对左值的推导进行了特别规定，是因为要实现完美转发
                                    // 因此这里看起来好像是左值被绑定到右值引用，
                                    // 但实质上还是左值引用
#if _SHOW_ERROR_CASE
    int& y1 = add(1, 2);            // 错误，右值不能绑定到非常量左值引用
    int& y2 = x3;                   // 错误，常量左值不能绑定到非常量左值引用
    int&& y3 = x1;                  // 错误，左值不能绑定到右值引用
    int&& y4 = add_const(1, 2);     // 错误，常量右值不能绑定到非常量右值引用
    int const&& y5 = x1;            // 错误，左值不能绑定到右值引用，常量右值引用也不行
    int&& y6 = x5;                  // 错误，左值不能绑定到右值引用，x5虽然是右值引用，
                                    // 但由于已经是具名引用，因此变成了左值
#endif
}

 

有了这样一个规定，就简单了，首先右值可以被引用了，其次为了分辨对象是不是临时的，我们可以做两个重载的函数，其中一个的形参是左值引用，另一个的形参是右值引用，那么该函数被调用时，如果参数是左值（非临时对象）或者左值引用，编译器会自动调用前一个重载的函数，如果参数是右值（临时对象）或者右值引用，则会自动调用后一个重载的函数，这样我们就可以准确的对左值和右值分开处理了。根据此原理，我们对前面例子中的int_array类进行修改，增加一个拷贝构造函数重载，和一个赋值操作符重载，用来接受右值引用，并修改使用的地方。示例代码如下：

// 拷贝构造函数重载，其实是转移构造函数，接受非常量右值，用于转移内部数据，
// 对于常量的右值，由于不能修改内容，还是需要拷贝，正好走传统的拷贝构造函数
int_array(int_array&& src)
{
    cout << "  int_array::int_array(int_array&&)" << endl;
    // 直接转移内部数据，避免了额外的拷贝
    m_buffer = src.m_buffer;
    m_size = src.m_size;
    src.m_buffer = 0;
    src.m_size = 0;
}

// 赋值操作符重载，其实可以看做交换操作符，接受非常量右值，用于交换内部数据
// 对于常量右值，由于无法修改其内部数据，还是需要拷贝，正好走传统的赋值操作符
int_array& operator=(int_array&& rhs)
{
    cout << "  int_array& int_array::operator=(int_array&&)" << endl;
    if (this != &rhs)
    {
        // 交换内部数据，这样等下销毁的就是这个对象现在的内部数据了，
        // 从而避免了不必要的拷贝
        swap(m_buffer, rhs.m_buffer);
        swap(m_size, rhs.m_size);
    }
    return *this;
}

// 生成一个有两个元素的int_arry，采用了转移语义减少拷贝
int_array new_make_int_array2(int v1, int v2)
{
    int_array result(2);    // 调用构造函数
    result.set_at(0, v1);
    result.set_at(1, v2);

    // 通过move函数将result对象从左值转成右值，
    // 从而调用int_array的转移构造函数，以减少不必要的拷贝
    return int_array(std::move(result));
}

// 生成一个有size个元素的int_arry，采用了转移语义减少拷贝
int_array new_make_int_array(unsigned int size, ...)
{
    if (size > 10000000)    // 如果太大则返回一个空的
        // 这里由于int_array()本事就是一个无名对象，也就是右值，
        // 从而自动调用了int_array的转移构造函数，没有不必要的拷贝
        return int_array(); // 调用

    int_array result(size); // 调用构造函数
    va_list args;
    va_start(args, size);
    for (unsigned int i = 0; i < size; ++i)
    {
        int v = va_arg(args, int);
        result.set_at(i, v);
    }

    // 通过move函数将result对象从左值转成右值，
    // 从而调用int_array的转移构造函数，以减少不必要的拷贝
    return int_array(std::move(result));
}

void new_example()
{
    cout << endl << "enter" << endl;

    cout << endl << "step1" << endl;

    // 如果没有RVO，应该调用一次构造函数，两次转移构造函数，没有不必要的拷贝
    // 由于RVO，实际上只调用了一次构造函数，一次转移构造函数
    int_array ia1 = new_make_int_array2(10, 20);

    cout << endl << "step2" << endl;

    // 如果没有RVO，应该调用一次构造函数，一次转移构造函数，一次交换等于操作符，
    // 由于RVO，实际上只调用了一次构造函数，一次交换等于操作符，没有不必要的拷贝
    ia1 = make_int_array2(100, 200);

    cout << endl << "step3" << endl;

    // 如果没有RVO，应该调用一次构造函数，两次转移构造函数，没有不必要的拷贝
    // 由于RVO，实际上只调用了一次构造函数，一次转移构造函数
    int_array ia2 = make_int_array(5, 1, 2, 3, 4, 5);

    cout << endl << "step4" << endl;

    // 调用了一次构造函数，一次转移构造函数，一次交换语义的等于操作符，
    // 没有不必要的拷贝
    ia2 = make_int_array(3, 1, 2, 3);

    cout << endl << "exit" << endl;
}

这个示例代码已经完全消除了不必要的拷贝，之前的性能问题得到了彻底地解决。我们发现代码里面用到了std::move()这个函数，接下来我们仔细讲解这个函数。

 

了解std::move()

很多时候，我们需要把左值引用转换成右值。原因通常有两个：一个原因是我们明确知道该左值不久后将被销毁，而我们需要转移其中的内部数据到其它对象中，例如上例中new_make_int_array()函数中的用法；另一个原因是由于右值一旦被具名引用，哪怕是具名的右值引用，它也会变成左值，因此需要将它恢复成右值，这个描述很拗口，但的确就是这样。

标准库中提供了std::move()这个模板函数，用来干这个转换的差事。它接收一个引用，并强制类型转换成右值引用，然后返回。由于函数返回值是不具名的右值引用，因此它还是右值。具体的实现代码如下：

template<typename _Tp>
inline typename std::remove_reference<_Tp>::type&& move(_Tp&& __t)
{
    return static_cast<typename std::remove_reference<_Tp>::type&&>(__t);
}

 

std::move()从名字上看，通常会产生错误的理解，以为移动临时对象内部数据的操作是由它完成的。看了代码就知道了，根本不是那么回事，它仅仅完成一个语义上的转换，将左值变成右值而已，而且没有任何性能损失。由于std::move()的语义是转成右值，以便接下来被转移，那么被传入到move函数的参数，在move调用过后，就最好不要再访问了，以免访问到错误的值。

完美转发(perfect forwarding)

最后我们讲一下完美转发，仔细讲起来会比较复杂。简单来说，在编写函数模板的过程中，可能需要把模板实参的左右值特性和常量性完美的保持下来，转发给其它的函数。在C++现行标准中，需要为每一个左右值特性和常量性作一个函数重载，如果函数只有一个形参，需要至少4个重载，如果函数模板有3个参数，则需要4的3次方=64个重载，因此很难做到统一的解决方案。C++0x通过右值引用，加上引用折叠(reference collapsing)，以及左值引用经过函数模板推导还是左值引用的特殊规定，较好的实现了完美转发，就是std::forward()这个模板函数。其实现代码如下：

 

template<class _Ty>
_Ty&& forward(typename identity<_Ty>::type& _Arg)
{
   return ((_Ty&&)_Arg);
}

 

引用折叠（reference collapsing）

补充介绍一下引用折叠，这是C++0x为了实现移动语义(move semantics)和完美转发(perfect forwarding)而增加的规定。简单罗列一下规则，就很清楚了：
A& &等价于A&

A& &&等价于A&

A&& &等价于A&

A&& &&等价于A&&

总结

1. 右值引用的确带来了性能提升的可能，也带来了完美转发。但性能的提升需要额外的编码，用来实现转移和交换行为。

2. 左值和右值的概念，并不是指等号的左边还是右边，而是指该表达式代表的对象是否是持久的，持久的就是左值，反之是右值。我们也可以用是否具名来判断，具名的是左值，反之是右值（非具名左值引用除外）。

3. std::move()函数用于语义上的转移，将左值转成右值，而不是实质上数据的转移，实质性的转移需要每个类单独编码实现。

4. std::forward()函数实现完美转发，可用于模板函数中完美的传递参数。