C++ - string 基本版

真正去了解如何写一个string类的时候，发现有好多知识点。

• 复制控制（复制构造函数、赋值操作符、析构函数）
• 运算符重载（+, ==, !=, <, <=, >, >=, +=, []等等）
• 深拷贝（对于字符串拷贝的处理）
• 友元（cin, cout）
• 内联函数（为了提高效率，这些函数都是内联函数）
• const的用法（返回值为常量、常量函数、输入为常量）
• 引用（输入为引用、返回值为引用（如+, []））
• 异常安全（operator=）

这些也还只是基本版的内容，还有

• 隐式共享写时拷贝（智能指针）
• C++11的右值引用、Move语义
• iterator
• gcc中string（basic_string）的写法又是另外一种层面的东西了……

本文给出基本版的代码

#include <iostream>
#include <vector>
#include <string>
#include <iomanip> // setw
#include <cstdio>
using namespace std;

class MyString { // inline
public:
    // constructor
    MyString(const char* str = NULL);
    MyString(const MyString&);
    MyString(size_t, char); // ? memset?
    // destructor
    ~MyString();

    bool empty();
    size_t size() const; // string::size_type?

    const char* c_str() const;
    void swap(MyString&);
    // operator +, ==, !=, <, <=, >, >=, +=
    char& operator[](size_t); // unsigned int??
    MyString& operator=(const MyString&);
    MyString operator+(const MyString&) const;
    bool operator==(const MyString&);
    // friend istream, ostream
    friend istream& operator>>(istream&, MyString&);
    friend ostream& operator<<(ostream&, MyString&);
private:
    char *m_data;

};

int main() {
    MyString mstr, s1, s2;
    cin >> mstr;
    cout << mstr << endl;
    mstr[0] = 'k';
    cout << mstr << endl;
    s1 = s2 = mstr;
    s2[2] = '3';
    cout << s1 << " " << (s1 == s2) << " " << s2 << endl;
    MyString s3(10, 'm');
    cout << s3 << endl;
    return 0;
}
inline MyString::MyString(const char* str) {
    // error C2572: “MyString::MyString”: 重定义默认参数 : 参数 1  // 去掉 = NULL
    if (!str) {
        m_data = new char[1];
        m_data[0] = '\0';
    }
    else {
        m_data = new char[strlen(str) + 1];
        strcpy(m_data, str);
    }
}
inline MyString::MyString(const MyString &object) {
    m_data = new char[object.size() + 1];
    strcpy(m_data, object.c_str());
}
inline MyString::MyString(size_t n, char ch) {
    m_data = new char[n + 1];
    memset(m_data, ch, n);
    m_data[n] = '\0';
}
inline MyString::~MyString() {
    delete []m_data;
}
size_t MyString::size() const {
    return strlen(m_data);
}
const char* MyString::c_str() const {
    return m_data;
}

void MyString::swap(MyString &rhs) {
    std::swap(m_data, rhs.m_data);
}

char& MyString::operator[](size_t i) {
    // 考虑错误处理
    return m_data[i];
}
MyString& MyString::operator=(const MyString& rhs) {
    if (this != &rhs) {
        MyString temp(rhs);
        swap(temp);
    }
    return *this;
}
bool MyString::operator==(const MyString& rhs) {
    return strcmp(m_data, rhs.c_str()) ? false : true;
}
MyString MyString::operator+(const MyString& rhs) const {
    MyString newS;
    //if (!rhs.m_data) { // 不可能为NULL
    //  newS = *this;
    //}
    //else if (!this->m_data) {
    //  newS = rhs.m_data;
    //}
    //else {
        newS.m_data = new char[size() + rhs.size() + 1];
        strcpy(newS.m_data, m_data);
        strcat(newS.m_data, rhs.m_data);
    //}
    return newS;
}

istream& operator>>(istream& in, MyString& rhs) {
    // 第一种方法：字符串长度受限
    //char temp[255];
    //in >> setw(255) >> temp;
    rhs = MyString(temp); // ok
    //rhs = temp;
    strcpy(rhs.m_data, temp); // ??有问题，确实有问题，m_data并没有分配空间，因此也可以先分配空间再拷贝
    //return in;

    // 第二种方法：字符串长度不受限，但在个别情况下有bug，详见注释
    //const int BUFFER_SIZE = 255; // 可以以5来做测试
    //char buffer[BUFFER_SIZE];
    //char *end = buffer + BUFFER_SIZE - 1;
    //rhs = ""; // clear
    //do {
    //  *end = '#';
    //  //in >> setw(BUFFER_SIZE) >> buffer; // 如果输入恰好是BUFFER_SIZE - 1，则会出问题
    //  //in.get(buffer, BUFFER_SIZE); // 并不能以空格分隔，直接输入换行也会出问题，暂时还不清楚为什么？难道是因为get了两次？
    //  in.get(buffer, BUFFER_SIZE, ' '); // 如果以空格分隔，又不能识别换行
    //  rhs += buffer;
    //} while (*end == '\0');
    //in.get();
     http://www.cplusplus.com/reference/istream/istream/get/
     The delimiting character is not extracted from the input sequence if found, 
     and remains there as the next character to be extracted from the stream (see 
     getline for an alternative that does discard the delimiting character).
    //return in;

    // 第三种方法：单字符处理，尝试get(char &c)
    const int BUFFER_SIZE = 255; // 可以以5来做测试
    char buffer[BUFFER_SIZE];
    int i = 0;
    char ch;
    rhs = "";
    // 标准输入流忽略空格和\n // http://www.cplusplus.com/reference/istream/istream/operator%3E%3E/
    do {
        in.get(ch);
    } while (ch == ' ' || ch == '\n');

    while (true) {
        if (ch == ' ' || ch == '\n') {
            buffer[i] = '\0';
            rhs += buffer;
            break;
        }
        else {
            buffer[i++] = ch;
            if (i == BUFFER_SIZE - 1) {
                buffer[i] = '\0';
                rhs += buffer;
                i = 0;
            }
        }
        in.get(ch);
    }
    return in;
}
ostream& operator<<(ostream& out, MyString& rhs) {
    out << rhs.m_data;
    return out;
}

最后附上一些参考资料。
STL 的string类怎么啦？
意图（Intention）、规格（Specification）、实现（Implementation）
标准C＋＋类string的Copy-On-Write技术（一）
引用计数器（智能指针）
C++面试中string类的一种正确写法
C++ string实现原理
C++ string类的隐式共享写时拷贝的实现及设计要点
C++中String类的实现