实现一个string类

需要实现的基本功能：构造函数、拷贝构造函数、赋值函数、析构函数. (以前合称big three, 现在叫做copy control)

  

class String {
public:
    String(const char* str = "");
    String(const String& rhs);
    ~String();
    String& operator=(const String& rhs);
    size_t size const();
    const char* c_str const();
private:
    char* data;
};

/* 不简洁版本
String::String(const char* str) {
    if (str == NULL) {
        data = new char[1];
        *data = '';
    } else {
        int len = strlen(str);
        data = new char[len + 1];
        strcpy(data, str);
    }
}
*/

String::String(const char* str) {
    data = new char[strlen(str) + 1];
    strcpy(data, str);
}

String::~String() {
    delete[] data;
}

String::String(const String& rhs) {
    data = new char[rhs.size() + 1];
    strcpy(data, rhs.c_str());
}

// bad version
String& String::operator=(const String& rhs) {
    if (this != &rhs) {
        delete[] data;
        data = new char[rhs.size() + 1];
        strcpy(data, rhs.c_str());
    }
    return *this;
}

size_t String::size() const{
    return strlen(data);
}

const char* String::c_str const() {
    return data;
}

 改进版：【详情参考ref4、剑指offer第一题】

上面的拷贝构造函数有个潜在隐患：String类涉及到内存分配操作，这个new操作可能会抛出异常。

解决方法：

可以通过”copy and swap“的策略来实现。其原理很简单：即先对打算修改的对象做出一个副本（copy），在副本上做必要的修改。如果生成副本时出现任何异常，原对象依然能保证不变。如果修改成功，则通过不抛出任何异常的swap函数将副本和原对象进行交换（swap）。[ ref ]

String& String::operator=(const String &rhs) {
    String tmp(rhs);
    swap(data, tmp.data);
    return *this;
}

如果把参数中的引用传递换成值传递，那就相当于自动创建出一个临时对象来。如下是另一种等价形式。

String& String::operator=(String rhs) {
    swap(data, rhs.data);
    return *this;
}

在swap之后，相当于两指针指向的内存区域进行了互换。当退出函数时，tmp生命周期已到，将被销毁，但是它销毁时释放的是交换后的内存区域，即原来的data所指的内存区域；它本来指向的内存区域现在归data管了，不会被释放。

ref2和ref5都考虑了异常安全的问题。

ref：

1. 《高质量C/C++程序设计指南》附录A,B (可能有错误)

2. http://coolshell.cn/articles/10478.html

3. http://noalgo.info/382.html

4. http://blog.csdn.net/worldwindjp/article/details/12967443

5. http://guochunyang.me/2014/10/17/c++-11-zhiyouzhi-yinyong--san---shiyong-c++-11-bianxie-string-lei-yiji--yichang-anquan--de--yunsuanfu/