C++ string 类模拟实现

既然要把常量字符串复制过来，首先要知道它的长度 (strlen(str) 计算长度不包括 '\0'，所以要 +1)，然后让成员变量 _str 指向堆上新 new 的空间。空间有了接下来就可以把字符串复制过来了，而 C 语言中 strcpy 函数就是一个很好的选择。从上面代码可以看出来我们多次调用 strlen 函数来计算字符串长度，可不可以只使用一次，并且将有值构造和默认构造合二为一？

2.1.3 合并

string(const char* str) : _size(strlen(str)) {
    _str = new char[_size + 1];
    _capacity = _size;
    strcpy(_str, str);
}

合并之后它可以同时作为默认构造函数和常量字符串构造函数。我们首先在初始化列表中确定了字符串的长度并初始化了大小和容量，然后在构造函数体中分配适当大小的内存并将字符串复制到新内存中。

2.2 拷贝构造 (深拷贝)

// 深拷贝
string(const string& s) {
    _str = new char[s._capacity + 1];
    _size = s._size;
    _capacity = s._capacity;
    strcpy(_str, s._str);
}

// 浅拷贝
string(const string& s) {
    _str = s._str; // 直接复制指针
    _size = s._size;
    _capacity = s._capacity;
}

回顾一下深拷贝与浅拷贝基本知识内容就基本上懂为什么要写深拷贝而不是以往的浅拷贝。

深拷贝： 复制对象时，分配新的内存，并复制指针指向的内容。结果是两个对象各自拥有独立的内存，不会互相影响。

浅拷贝： 复制对象时，仅复制指针，而不复制指针指向的内容。结果是两个对象共享同一块内存，这可能导致一个对象修改数据，另一个对象的数据也被修改，甚至导致双重释放问题（两个对象在析构时都试图释放同一块内存）。

2.3 析构

~string() {
    delete[] _str;
    _str = nullptr;
    _size = 0;
    _capacity = 0;
}

讲完了如何初始化，那就该讲讲怎么遍历了。

三、遍历字符串

遍历字符串有 operator[]、迭代器两种方式，那现在让我们模拟实现它们吧。

3.1 operator[]

重载 operator[] 可以让我们像访问数组元素一样访问类的成员变量。

char& operator[](size_t pos) {
    assert(pos < _size);
    return _str[pos];
}

3.2 迭代器

我们一般说迭代器类似指针但是却不是指针。

typedef char* iterator;
iterator begin() { return _str; }
iterator end() { return _str + _size; }

四、对内容进行修改

4.1 reserve

// 开空间
void reserve(size_t n) {
    if(n > _capacity) {
        char* tmp = new char[n + 1];
        strcpy(tmp, _str);
        delete[] _str;
        _str = tmp;
        _capacity = n;
    }
}

4.2 push_back

// 尾部添加单个字符
void push_back(char ch) {
    if(_size == _capacity) {
        reserve(_capacity == 0 ? 4 : _capacity * 2);
    }
    _str[_size] = ch;
    ++_size;
    _str[_size] = '\0';
}

4.3 append

// 尾部添加一个字符串
void append(const char* str) {
    size_t len = strlen(str);
    if(len + _size > _capacity) {
        reserve(len + _size);
    }
    strncpy(_str + _size, str, len);
    _size += len;
}

4.4 operator+=

// 尾插单个字符版
string& operator+=(char ch) {
    push_back(ch);
    return *this;
}

// 尾插字符串版
string& operator+=(const char* str) {
    append(str);
    return *this;
}

// 尾插字符串测试代码
int main() {
    using namespace bit;
    string str;
    str += "Hello, ";
    str += "world!";
    return 0;
}

当执行 str += "Hello, "; 时，编译器会识别出这是 operator+= 操作，并且调用我们为 String 类定义的 operator+= 函数。

在 operator+= 函数内部，this 是一个指向 str 对象的指针。所以在函数内部，this-> 和 str. 是等价的。

在 operator+= 函数中，调用了 append(str)，其中 str 是传入的 C 字符串 "Hello, "。此时，this 仍然指向 str 对象。

operator+= 返回当前对象的引用 *this，即 str 的引用。

4.5 insert

// 在指定位置插入字符
void insert(size_t pos, char ch) {
    assert(pos <= _size);
    if(_size == _capacity) {
        reserve(_capacity == 0 ? 4 : _capacity * 2);
    }
    size_t end = _size;
    while(end >= pos) {
        _str[end + 1] = _str[end];
        --end;
    }
    _str[pos] = ch;
    _size += 1;
}

// 在指定位置插入字符串
void insert(size_t pos, const char* str) {
    assert(pos <= _size);
    size_t len = strlen(str);
    if(_size + len > _capacity) {
        reserve((_size + len) * 2);
    }
    size_t end = _size;
    while(end >= pos) {
        _str[end + len] = _str[end];
        --end;
    }
    strncpy(_str + pos, str, len);
    _size += len;
}

4.6 erase

// 从指定位置删除指定长度的字符
void erase(size_t pos, size_t len = static_cast<size_t>(-1)) {
    assert(pos < _size);
    if(len == static_cast<size_t>(-1) || len + pos > _size) {
        _str[pos] = '\0';
        _size = pos;
    } else {
        strcpy(_str + pos, _str + pos + len);
        _size -= len;
    }
}

当 pos + len 超过了有效数据的总长度时，说明操作已经超出范围，这时候最简单的做法就是从 pos 开始删除后面的所有内容。反之，如果 len 没有超出范围，那么就不需要做任何删除操作。

• 如果没有显式传递 len 参数，它默认会使用 npos 作为 len 的值。npos 通常表示一个无效位置或者未找到的值，通常等同于 -1（但在 size_t 类型中，-1 实际上是一个非常大的正整数）。
• 当 len == npos 时，意味着你没有指定要删除或操作的长度。在这种情况下，函数通常会理解为你希望操作直到字符串的末尾。

4.7 find

// 查找字符
size_t find(char ch, size_t pos = 0) const {
    assert(pos < _size);
    for (size_t i = pos; i < _size; i++) {
        if (_str[i] == ch) return i;
    }
    return static_cast<size_t>(-1);
}

// 查找字符串
// const 在函数签名后面：表示这个成员函数不能修改所属对象的状态。
size_t find(const char* str, size_t pos = 0) const {
    assert(pos < _size);
    // 用于查找一个字符串在另一个字符串中的首次出现位置
    // 找到返回它在 _str + pos 中首次出现的位置；如果未找到，m 将为 nullptr。
    const char* m = strstr(_str + pos, str);
    if(m) {
        return m - _str; // 指针减去指针返回它们相差的个数
    } else {
        return static_cast<size_t>(-1);
    }
}

4.8 substr

// 在原字符串中获取子串
string substr(size_t pos = 0, size_t len = static_cast<size_t>(-1)) {
    string Tmp;
    assert(pos < _size);
    if(pos + len > _size || len == 0) {
        for(int i = pos; i < _size; i++) {
            // 字符被添加到了 Tmp 对象所指向的字符串存储空间中，而这个存储空间的指针是 Tmp 对象的一部分。
            Tmp += _str[i];
        }
    } else {
        for(int i = pos; i < len + pos; i++) {
            Tmp += _str[i];
        }
    }
    return Tmp;
}

五、重载函数

5.1 operator=

// 赋值重载
string& operator=(const string& s) {
    if(this != &s) {
        char* Tmp = new char[strlen(s._str) + 1];
        strcpy(Tmp, s._str);
        delete[] _str;
        _str = Tmp;
        _size = s._size;
        _capacity = s._capacity;
    }
    return *this;
}

5.2 operator==

// 几个比较函数
bool operator==(const string& s1, const string& s2) {
    int m = strcmp(s1._str, s2._str);
    return m == 0;
}

bool operator<(const string& s1, const string& s2) {
    int x = strcmp(s1._str, s2._str);
    return x < 0;
}

5.3 operator<<

// 流插入与提取
ostream& operator<<(ostream& out, const string& s) {
    for(auto e : s) {
        out << e;
    }
    return out;
}