C++11之右值引用（三）：使用C++11编写string类以及“异常安全”的=运算符

前面两节，说明了右值引用和它的作用。下面通过一个string类的编写，来说明右值引用的使用。

相对于C++98，主要是多了移动构造函数和移动赋值运算符。

先给出一个简要的声明：

1class String
2{
3public:
4    String();
5    String(const char *s); //转化语义
6    String(const String &s);
7    String(String &&s);
8    ~String();
9
10    String &operator=(const String &s);
11    String &operator=(String &&s);
12
13    friend ostream &operator<<(ostream &os, const String &s)
14    {
15        return os << s.data_;
16    }
17private:
18    char *data_;
19};

下面依次实现每个函数。

第一个是默认构造函数：

1String::String()
2:data_(new char[1])
3{
4    *data_ = 0;
5    cout << "default" << endl;
6}

然后是char*版本的构造函数：

1String::String(const char *s)
2:data_(new char[strlen(s) + 1])
3{
4    ::strcpy(data_, s);
5    cout << "char *" << endl;
6}

重点来了，我们提供移动构造函数：

1String::String(String &&s)
2:data_(s.data_)
3{
4    cout << "move construct" << endl;
5    s.data_ = NULL; //防止释放data
6}

这里最重要的一点就是要把s的data置为NULL，因为s是个右值，马上就要析构。这样就成功实现了偷取s的内容。

析构函数：

1String::~String()
2{
3    delete[] data_;
4}

下面我们提供赋值运算符，这里注意一点：

一是处理自我赋值，二是要返回自身引用。

1String &String::operator=(const String &s)
2{
3    if(this != &s)
4    {
5        delete[] data_;
6        data_ = new char[strlen(s.data_) + 1];
7        ::strcpy(data_, s.data_);
8    }
9    return *this;
10}
11
12String &String::operator=(String &&s)
13{
14    if(this != &s)
15    {
16        cout << "move assignment" << endl;
17        delete[] data_;
18        data_ = s.data_;
19        s.data_ = NULL;
20    }
21    return *this;
22}

后面的移动构造函数，依然要把s的data置为NULL。

上面两个函数看似正确，但是没有处理发生异常的情况，如果new时发生异常，但是此时原本的data已经被delete，造成错误。

如何解决？

我们提供一个swap函数：

1void String::swap(String &s)
2{
3    std::swap(data_, s.data_);
4}

一种好的处理方案是：

1String &String::operator=(const String &s)
2{
3    String temp(s);
4    swap(temp);
5
6    return *this;
7}
8
9String &String::operator=(String &&s)
10{
11    String temp(s);
12    swap(temp);
13
14    return *this;
15}

这样，即使生成temp时发生异常，也对自身没有影响。

注意这里没有处理自我赋值，因为自我赋值发生的情况实际比较少，而之前的代码第一行是delete，则必须处理自我赋值。

上面两个赋值运算符可以直接合为一个：

1String &String::operator=(String s)
2{
3    swap(s);
4
5    return *this;
6}

事实上，我们在前面也提到过，除了构造函数之外，X &x和X &&类型的函数，可以合二为一为X x，采用传值。

这样，我们的最后一个实现，保证了异常安全。

测试代码：

1int main(int argc, char const *argv[])
2{
3    String s("foo");
4    String s2(s);
5    //String s3(std::move(String("bar")));
6    String s3(String("bar")); //编译器优化 直接使用char*
7    cout << s3 << endl;
8
9    s3 = s;
10    s3 = String("hello");
11    cout << s3 << endl;
12    s3 = std::move(s2);
13    cout << s3 << endl;
14
15    return 0;
16}

注意：

String s3(String("bar"));

会被编译器优化为

String s3(“bar”)

可以显式使用：

String s3(std::move(String("bar")));

完毕。