【C++】string

string类的常用接口

string相关文档

构造

接口	接口说明
string()	构造一个空 string 对象，即空的字符串
string (const char* s)	使用 C-string 来构造 string 类对象
string (const string& s)	拷贝构造

Capacity

接口	接口说明
size（重点）	返回字符串有效字符长度
length	返回字符串有效字符长度
capacity	返回空间总大小
empty（重点）	检测字符串释放为空串，是返回 true，否则返回 false
clear（重点）	清空有效字符，不会改变空间
reserve（重点）	为字符串预留空间
resize（重点）	将有效字符的个数改成 n 个，多出的空间用字符 c 填充

其中，resize(size_t n, char c) 的功能较为复杂：

• n < size，会删除字符串到指定长度

• n > size，会填充字符串，默认填充为’\0’，如果设置 c 被设置了，就会填充为 c

• n > capacity，会扩容并填充字符串

元素访问

接口	接口说明
operator[]（重点）	返回pos位置的字符，const string类对象调用
begin+end	begin获取第一个字符的迭代器，end获取最后一个字符下一个位置的迭代器
rbegin+rend	rbegin获取最后一个字符的迭代器，rend获取第一个字符前一个位置的迭代器
范围for	C++11 支持更简洁的范围for的新遍历方式

• stirng 类的底层是字符数组，因为是数组，自然支持[]连续访问

• 迭代器类似于指针，但有可能是指针，也可能不是。为什么呢？不同的容器，不同的编译器，实现迭代器的方式各有不同。

但是迭代器用起来很像指针，如下：

其中，begin和end维护的范围是左闭右开的：[begin, end)

• 范围for是 C++11 中新加入的遍历方式，它可以自动遍历，自动终止

for(类型 元素 : 对象) // 类型一般使用 auto 自动推导

范围for的底层是使用迭代器来实现的，如果我们实现了迭代器，不用特意实现范围for，直接就可以使用

修改

接口	接口说明
push_back	在字符串后尾插字符c
append	在字符串后追加一个字符串
insert	在字符串中任意位置插入字符/字符串
erase	在字符串中任意位置删除指定长度的字符
operator+=（重点）	在字符串后追加字符串str
c_str（重点）	返回 C 格式字符串
swap	交换两个string对象的值
find+npos（重点）	从字符串pos位置开始往后找字符c，返回该字符在字符串中的位置
rfind	从字符串pos位置开始往前找字符c，返回该字符在字符串中的位置
substr	在str中从pos位置开始，截取n个字符，然后将其返回

非成员函数

接口	接口说明
operator+	尽量少用，因为传值返回，导致深拷贝效率低
operator>>（重点）	输入运算符重载
operator<<（重点）	输出运算符重载
getline（重点）	获取一行字符串
relational operators（重点）	大小比较

string类的模拟实现

关于string类的使用这里简单列举了上述接口，string类的接口很多，我们只需要掌握最常用的就好。下面我们来模拟实现一个string类，目的不是完美还原一个string类，而是加深我们对string的底层理解，这样我们使用 string 时会有更好的理解，使用起来更加得心应手

命名空间隔离

为了防止我们实现的 string 和库里的 string 发生冲突，我们可以创建一个命名空间，与外面隔离，防止命名冲突

namespace ns1
{
        class string
        {};
}

成员变量

• char* _str：字符数组的地址，用来存储字符串
• size_t _size：用来表示字符串的实际长度
• size_t _capacity：用来表示空间的总大小

class string
{
private:
        char* _str = nullptr;
        size_t _size = 0;
        size_t _capacity = 0;
};

构造

默认构造

无参构造

如果创建对象时不传参数，就是要创建一个空串，那么构造函数是否就可以这样写呢？

string()
        :_str(nullptr)
        ,_size(0)
        ,_capacity(0)
{}

这样写是有问题的：

1. 空串虽然是空的，但是空串还是有一个字符 ‘\0’ 的。上面的写法中，空串真的就什么都没有
2. 调用 c_str 时会有问题：调用 c_str 会返回string对象的 c字符串，如果返回nullptr，访问就会出现问题，例如打印

string()
        :_str(nullptr)
        ,_size(0)
        ,_capacity(0)
{}

const char* c_str() const
{
        return _str;
}

void test1()
{
        string s1;
        cout << s1.c_str() << endl;
}

所以应该至少申请一个空间，存储 ‘\0’

string()
        :_str(new char[1])
        ,_size(0)
        ,_capacity(0)
{
        _str[0] = '\0';
}

c-string构造函数

string类还支持使用 c-string 来创建对象

string s1("hello world");

所以这个构造函数的参数是一个常量字符串str，可以使用strlen获得 str 的长度 len，再使用 new 申请 len+1 长度的空间。为什么需要多申请一个空间呢？——用来存储 ‘\0’

然后再将str的数据拷贝到申请的空间内，可以使用strcpy，这个函数会顺便把str的 ‘\0’ 拷贝过来

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

        // 拷贝数据
        strcpy(_str, str);
}

测试：

对于上面的两个构造函数，我们可以将它们合并为一个缺省的默认构造函数

string(const char* str = "")
{
        _size = _capacity = strlen(str);
        _str = new char[_size + 1];

        // 拷贝数据
        strcpy(_str, str);
}

缺省值是一个 ""，既可以用来表示空串，其中也自带一个 ‘\0’

测试：

析构函数

析构函数的功能是将string对象申请的空间释放掉

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

拷贝构造

用已存在的对象创建一个新的对象

string s1("hello world")
string s2(s1);

这里的思路依旧是：获得参数字符串的长度->开空间->拷贝数据，就不详细写了

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

测试：

赋值重载

string& operator= (const string& str);

和拷贝构造类似的思路

string& operator=(const string& s)
{
        char* tmp = new char[s._capacity + 1];
        strcpy(tmp, _str);

        delete[] _str;
        _str = tmp;
        _size = s._size;
        _capacity = s._capacity;
        return *this;
}

测试：

Capacity

size && capacity

返回string对象中 size 和 capacity 的值

size_t size() const
{
        return _size;
}

size_t capacity() const
{
        return _capacity;
}

empty

检测字符串释放为空串，是返回 true，否则返回 false

bool empty() const
{
        return _size == 0;
}

测试：

clear

清空有效字符，不会改变空间。虽然是要删除数据，但我们并不需要真的删，只需要把 _size 置零，然后将 _str[_size] 设置为 ‘\0’ 即可

void clear()
{
        _size = 0;
        _str[_size] = '\0';
}

测试：

reserve

void reserve (size_t n = 0);

为字符串预留空间，如果我们要向字符串中频繁插入数据，可以预先开好空间，这样就可以避免频繁扩容的损耗

• 只有当 n > _capacity 时，才需要进行申请空间的操作，否则什么都不用做
• 由于 c++ 并没有提供类似realloc这样进行原地扩容的接口，所以我们只能 new 一块新的空间，将旧空间的数据拷贝一下，删除旧空间

void reserve(size_t n = 0)
{
        if (n > _capacity)
        {
                char* tmp = new char[n + 1];
                strcpy(tmp, _str);

                delete[] _str;
                _str = tmp;
                _capacity = n;
        }
}

测试：

resize

void resize (size_t n, char c = '\0');

将有效字符的个数改成 n 个，多出的空间用字符 c 填充

• n < size，会删除字符串到指定长度
• n > size，会填充字符串，默认填充为’\0’，如果设置 c 被设置了，就会填充为 c
• n > capacity，会先扩容并填充字符串

void resize(size_t n, char c = '\0')
{
        // 删除
        if (n <= _size)
        {
                _str[n] = '\0';
                _size = n;
        }
        else // 填充
        {
                // 需不需要扩容，交给 reserve 去判断
                reserve(n);

                for (int i = _size; i < n; i++)
                        _str[i] = c;
                _str[n] = '\0';
                _size = n;
        }
}

元素访问

[]

      char& operator[] (size_t pos);
const char& operator[] (size_t pos) const;

因为string中的字符串是用字符数组存储的，所以string对象支持[]访问是符合直觉的。

• 方括号+下标不仅可以访问数据，还支持修改数据，所以我们可以返回字符引用
• 为了防止越界访问，我们可以给 pos 加个断言

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

测试：

同时为了让const对象也可以使用此函数，需要重载一个 const 版本

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

迭代器

      iterator begin();
const_iterator begin() const;

      iterator end();
const_iterator end() const;

虽然迭代器不一定是用指针实现的，但我们可以用指针模拟实现一个，毕竟迭代器用起来确实像指针

先把 char* 指针 typedef 成迭代器的样子

class string
{
public:
        typedef char* iterator;
        typedef const char* const_iterator;
        // ...
}

begin 就是返回一个指向字符串开始位置的指针；end 返回的是指向字符串末尾（‘\0’）的指针

iterator begin()
{
        return _str;
}

const_iterator begin() const
{
        return _str;
}

iterator end()
{
        return _str + _size;
}

const_iterator end() const
{
        return _str + _size;
}

测试：

范围for

范围for是基于迭代器实现的，所以只需要实现了迭代器，范围for自然就可以使用了

修改

push_back

void push_back (char c);

在字符串的尾部插入一个字符

• 插入之前，判断需不需要扩容；
• 如果容量满了，容量为0，就申请4个空间；否则扩容为2倍
• 将 _str[_size] 设置为c，_size++，最后将 _str[_size] 设置为’\0’

void push_back(char c)
{
        // 检查扩容
        if (_size == _capacity)
                reserve(_capacity == 0 ? 4 : 2 * _capacity);

        _str[_size] = c;
        _size++;
        _str[_size] = '\0';
}

测试：

append

void append(const char* str);

在字符串的尾部插入一个字符串str

• 先检查当前的容量是否可以容纳要插入的字符串str，不够就扩容
• 使用 strcpy 将str插入到字符串中
• 更新 _size 的长度

void append(const char* str)
{
        size_t len = strlen(str);
        if (_size + len > _capacity)
                reserve(_size + len);

        strcpy(_str + _size, str);
        _size += len;
}

测试：

operator+=

string& operator+= (char c);
string& operator+= (const char* s);

运算符重载，可以使 string 对象 += 一个字符或者字符串。可以直接复用上面写的 push_back 和 append

string& operator+=(char c)
{
        push_back(c);
        return *this;
}

string& operator+=(const char* str)
{
        append(str);
        return *this;
}

测试：

insert

void insert (size_t pos, char c);
void insert (size_t pos, const char* s);

在字符串的 pos 位置插入一个字符/字符串，这就需要挪动数据了，所以 insert 的插入效率不高

• 插入数据，首先还是要检查容量
• 在 pos 位置插入数据，就需要将pos位置及其后面的字符往后挪动一位，包括’\0’也要挪动
• 定义一个指针end，指向’\0’后面，然后开始向前遍历，每次都把前一个位置的字符复制到当前位置

• 数据挪动完成后，将 pos 位置的数据替换为 c，更新_size

void insert(size_t pos, char c)
{
        assert(pos <= _size); // 支持尾插

        // 检查扩容
        if (_size == _capacity)
                reserve(_capacity == 0 ? 4 : 2 * _capacity);

        // 挪动
        size_t end = _size + 1;
        while (end > pos)
        {
                _str[end] = _str[end - 1];
                --end;
        }

        _str[pos] = c;
        ++_size;
}

测试：

insert插入一个字符串，思路是一样的，只需要注意下标之间的关系即可

• 在插入字符串时，可以使用 strncpy ，可以限定复制的字符个数

void insert(size_t pos, const char* str)
{
        // 检查容量
        size_t len = strlen(str);
        if (_size + len > _capacity)
                reserve(_size + len);

        // 挪动
        size_t end = _size + len;
        while (end >= pos + len)
        {
                _str[end] = _str[end - len];
                --end;
        }

        // 更新数据
        strncpy(_str + pos, str, len);
        _size += len;
}

测试：

insert 的复用

有了以上的两个insert，我们就可以将它们复用在 push_back 和 append 中

void push_back(char c)
{
         检查扩容
        //if (_size == _capacity)
        //        reserve(_capacity == 0 ? 4 : 2 * _capacity);

        //_str[_size] = c;
        //++_size;
        //_str[_size] = '\0';

        insert(_size, c);
}

void append(const char* str)
{
        /*size_t len = strlen(str);
        if (_size + len > _capacity)
                reserve(_size + len);

        strcpy(_str + _size, str);
        _size += len;*/
        
        insert(_size, str);
}

erase

void erase (size_t pos = 0, size_t len = npos);

在字符串中任意位置删除指定长度的字符，len 的缺省值是 npos

虽然 npos 的值为-1，但它是一个无符号整型，是一个非常大的数。所以当 len == npos 时，就代表把从 pos 位置开始向后的字符全部删除

我们的string也需要定义一个 npos，因为用到 npos 的地方有很多，所以把 npos 设置为静态成员变量

class string
{
    // ...
public:
        static int npos;
}
int string::npos = -1;

• len == npos 或者要删除的长度超过字符串末尾时，将 pos 之后的字符全部删除即可；否则只需要删除中间的部分字符
• 当我们要删除字符串中间的字符时，不需要真的删掉，只需要将后面的字符向前挪动，覆盖要删除的字符即可
• 因为只需要覆盖数据，不需要拷贝，所以直接用 strcpy 就可以做到，不需要我们手动挪动数据

void erase(size_t pos = 0, size_t len = npos)
{
        assert(pos < _size);

        if (len == npos || len > _size - pos) // pos + len可能会溢出
        {
                // 从 pos 开始全部删除
                _str[pos] = '\0';
                _size = pos;
        }
        else
        {
                // 部分删除
                strcpy(_str + pos, _str + pos + len);
                _size -= len;
        }
}

测试：

swap

void swap (string& str);

交换两个string对象的值。我们知道在c++库中，已经为我们提供了一个 swap 模板，为什么我们还需要写一个呢？

// swap 模板
template <class T> void swap ( T& a, T& b )
{
  T c(a); a=b; b=c;
}

可以看到，对于自定义类型，我们需要拷贝构造一个c，后面是两次赋值拷贝，一共经历了3次自定义类型的拷贝

而实际上我们的string进行swap并不需要这么多操作，只需要交换_str的指针，还有其他两个int类型的数据即可，这样只需要进行 3 次内置类型的拷贝即可，减少了消耗

void swap(string& s)
{
        std::swap(_str, s._str);
        std::swap(_size, s._size);
        std::swap(_capacity, s._capacity);
}

我们学了string的底层后，知道了调用string.swap()更好，但是不知道的人还是会调用库中的swap。为了避免这种情况，我们可以写一个全局的swap，如下：

// 全局
void swap(string& s1, string& s2)
{
        s1.swap(s2);
}

当同时存在模板和函数可以使用时，编译器会优先调用函数，而不是模板

测试：

find

size_t find (char c, size_t pos = 0) const;
size_t find (const char* s, size_t pos = 0) const;

从字符串pos位置开始往后找字符/字符串，返回该字符/字符串在字符串中的位置

• 找字符：只需定义一个指针从 pos 位置开始遍历，遇到符合条件的字符即返回其下标；找不到就返回 npos
• 找字符串：使用strstr函数即。strstr找到目标子串后，会返回其起始地址；否则返回空指针

size_t find(char c, size_t pos = 0) const
{
        assert(pos < _size);

        for (int i = pos; i < _size; i++)
                if (_str[i] == c)
                        return i;
        return npos;
}

size_t find(const char* s, size_t pos = 0) const
{
        const char* ret = strstr(_str + pos, s);
        if (ret)
                return ret - _str; // 返回下标
        return npos;
}

测试：

substr

string substr (size_t pos = 0, size_t len = npos) const;

在str中从pos位置开始，截取n个字符，然后将其返回

• 如果 len == npos 或者要截取的长度超过了字符串，那就从 pos 位置开始往后的字符全部截取
• 我们可以创建一个临时的string对象tmp，将要截取的字符 += 到tmp后返回即可

string substr(size_t pos = 0, size_t len = npos) const
{
        string tmp;

        // 全部截取
        if (len == npos || len > _size - pos)
        {
                for (int i = pos; i < _size; i++)
                        tmp += _str[i];
        }
        else
        {
                // 部分截取
                for (int i = pos; i < pos + len; i++)
                        tmp += _str[i];
        }
        return tmp;
}

测试：

非成员函数

大小比较

大小比较可以使用 strcmp 来实现，我们只要实现了==，再实现一个<或者>，就可以复用实现其他的了。这里很简单，就不详细说了

bool operator==(const string& s1, const string& s2)
{
        int ret = strcmp(s1.c_str(), s2.c_str());
        return ret == 0;
}

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

bool operator<=(const string& s1, const string& s2)
{
        return s1 == s2 || s1 < s2;
}

bool operator>(const string& s1, const string& s2)
{
        return !(s1 <= s2);
}

bool operator>=(const string& s1, const string& s2)
{
        return !(s1 < s2);
}

bool operator!=(const string& s1, const string& s2)
{
        return !(s1 == s2);
}

流插入<<

ostream& operator<< (ostream& os, const string& str);

流插入较为简单，只需要打印string中的字符串即可

ostream& operator<<(ostream& os, const string& str)
{
        for (auto e : str)
                os << e;
        return os;
}

测试：

流提取>>

istream& operator>> (istream& is, string& str);

相较于流插入的实现，流提取较麻烦一点

• 因为流提取是覆盖数据，所以我们需要先将 str 的有效字符清空。调用clear即可
• >> 遇到空格或者换行就会停下

先试着实现一下：

istream& operator>> (istream& is, string& str)
{
        str.clear();

        char ch;
        is >> ch;
        while (ch != ' ' && ch != '\n')
        {
                str += ch;
                is >> ch;
        }

        return is;
}

测试一下：

程序陷入无限循环，无论我们输入几行都不会结束。通过调试可以发现，ch 根本不会变为 ' ' 或者'\n'，直接跳过了

这是因为 >> 默认不会读空格或者回车，想要读到每个字符，我们可以使用istream类对象的get()函数，如下：

istream& operator>> (istream& is, string& str)
{
        str.clear();

        char ch;
        ch = is.get(); // 读每一个字符
        while (ch != ' ' && ch != '\n')
        {
                str += ch;
                ch = is.get();
        }

        return is;
}

测试：

getline

istream& getline (istream& is, string& str);

获取一行字符串

• 只需要将流提取的代码改一下就可以了，一直读字符，遇到回车才停止

istream& getline(istream& is, string& str)
{
        str.clear();

        char ch;
        ch = is.get();
        while (ch != '\n')
        {
                str += ch;
                ch = is.get();
        }

        return is;
}

测试：

关于流提取和getline的优化

在实现流提取和getline的过程中，string会频繁地插入数据，如果数据很多的话，可能会很频繁地扩容。那可不可以提前 reserve 空间，从而减少扩容损耗呢？

理论可以，但是我们不知道 reserve 多少是合适的

• 空间开少了，还是会频繁扩容
• 空间开多了，如果数据很少，例如只读进了1个字符，就会浪费空间

还有一个办法：创建一个中转站buff，每次都把字符读进中转站，当中转站满了时，就把中转站的字符一次性加到string中

这样就可以减少扩容的次数了

istream& operator>> (istream& is, string& str)
{
        str.clear();

        char ch;
        ch = is.get();

        char buff[128];
        int i = 0;
        while (ch != ' ' && ch != '\n')
        {
                // 字符放到buff
                buff[i++] = ch;
                // buff 满了，转移到string
                if (i == 127)
                {
                        buff[i] = '\0';
                        i = 0;
                        str += buff;
                }
                ch = is.get();
        }

        // 清理buff
        if (i > 0)
        {
                buff[i] = '\0';
                str += buff;
        }

        return is;
}

istream& getline(istream& is, string& str)
{
        str.clear();

        char ch;
        ch = is.get();

        char buff[128];
        int i = 0;
        while (ch != '\n')
        {
                // 字符放到buff
                buff[i++] = ch;
                // buff 满了，转移到string
                if (i == 127)
                {
                        buff[i] = '\0';
                        i = 0;
                        str += buff;
                }
                ch = is.get();
        }

        // 清理buff
        if (i > 0)
        {
                buff[i] = '\0';
                str += buff;
        }

        return is;
}

拷贝构造和赋值重载的现代写法

我们之前写的拷贝构造和赋值重载属于传统写法

// 传统写法
string(const string& s)
{
        _str = new char[s._capacity + 1];
        strcpy(_str, s._str);
        _size = s._size;
        _capacity = s._capacity;
}

string& operator=(const string& s)
{
        char* tmp = new char[s._capacity + 1];
        strcpy(tmp, _str);

        delete[] _str;
        _str = tmp;
        _size = s._size;
        _capacity = s._capacity;
        return *this;
}

我们需要手动地申请空间，复制数据，释放空间等。以下是现代写法

// 现代写法
string(const string& s)
{
        string tmp(s.c_str());
        swap(tmp);
}

string& operator=(string tmp)
{
        swap(tmp);
        return *this;
}

拷贝构造的现代写法：

• 通过调用构造函数，创建一个临时对象tmp，这个临时对象中的数据就是我们要拷贝的
• 再调用swap，将构造出的对象*this和临时对象tmp的数据进行交换
• 出了拷贝构造函数，临时对象自动销毁

赋值重载的现代写法与拷贝构造的现代写法思路相同，不过这里的临时对象是通过拷贝构造创建的

string& operator=(string tmp) // 传值传参，调用拷贝构造
{
        swap(tmp);
        return *this;
}

现代写法的好处就是复用已经实现的接口，减少代码书写；效率上和传统写法没什么差别

代码

#include <iostream>
#include <string.h>
#include <assert.h>
using namespace std;

namespace ns1
{
        class string
        {
        public:
                typedef char* iterator;
                typedef const char* const_iterator;
                // 默认构造
                string(const char* str = "")
                {
                        _size = _capacity = strlen(str);
                        _str = new char[_size + 1];

                        // 拷贝数据
                        strcpy(_str, str);
                }
                
                // 析构
                ~string()
                {
                        delete[] _str;
                        _str = nullptr;
                        _size = _capacity = 0;
                }

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

                // 容量
                size_t size() const
                {
                        return _size;
                }

                size_t capacity() const
                {
                        return _capacity;
                }

                bool empty() const
                {
                        return _size == 0;
                }

                void clear()
                {
                        _size = 0;
                        _str[_size] = '\0';
                }

                void reserve(size_t n = 0)
                {
                        if (n > _capacity)
                        {
                                char* tmp = new char[n + 1];
                                strcpy(tmp, _str);

                                delete[] _str;
                                _str = tmp;
                                _capacity = n;
                        }
                }

                void resize(size_t n, char c = '\0')
                {
                        // 删除
                        if (n <= _size)
                        {
                                _str[n] = '\0';
                                _size = n;
                        }
                        else // 填充
                        {
                                // 需不需要扩容，交给 reserve 去判断
                                reserve(n);

                                for (int i = _size; i < n; i++)
                                        _str[i] = c;
                                _str[n] = '\0';
                                _size = n;
                        }
                }

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

                iterator begin()
                {
                        return _str;
                }

                const_iterator begin() const
                {
                        return _str;
                }

                iterator end()
                {
                        return _str + _size;
                }
                
                const_iterator end() const
                {
                        return _str + _size;
                }

                // 修改
                void push_back(char c)
                {
                         检查扩容
                        //if (_size == _capacity)
                        //        reserve(_capacity == 0 ? 4 : 2 * _capacity);

                        //_str[_size] = c;
                        //++_size;
                        //_str[_size] = '\0';

                        insert(_size, c);
                }

                void append(const char* str)
                {
                        /*size_t len = strlen(str);
                        if (_size + len > _capacity)
                                reserve(_size + len);

                        strcpy(_str + _size, str);
                        _size += len;*/

                        insert(_size, str);
                }

                string& operator+=(char c)
                {
                        push_back(c);
                        return *this;
                }

                string& operator+=(const char* str)
                {
                        append(str);
                        return *this;
                }

                void insert(size_t pos, char c)
                {
                        assert(pos <= _size); // 支持尾插

                        // 检查扩容
                        if (_size == _capacity)
                                reserve(_capacity == 0 ? 4 : 2 * _capacity);

                        // 挪动
                        size_t end = _size + 1;
                        while (end > pos)
                        {
                                _str[end] = _str[end - 1];
                                --end;
                        }

                        _str[pos] = c;
                        ++_size;
                }

                void insert(size_t pos, const char* str)
                {
                        // 检查容量
                        size_t len = strlen(str);
                        if (_size + len > _capacity)
                                reserve(_size + len);

                        // 挪动
                        size_t end = _size + len;
                        while (end >= pos + len)
                        {
                                _str[end] = _str[end - len];
                                --end;
                        }

                        // 更新数据
                        strncpy(_str + pos, str, len);
                        _size += len;
                }

                void erase(size_t pos = 0, size_t len = npos)
                {
                        assert(pos < _size);

                        if (len == npos || len > _size - pos) // pos + len可能会溢出
                        {
                                // 从 pos 开始全部删除
                                _str[pos] = '\0';
                                _size = pos;
                        }
                        else
                        {
                                // 部分删除
                                strcpy(_str + pos, _str + pos + len);
                                _size -= len;
                        }
                }

                void swap(string& s)
                {
                        std::swap(_str, s._str);
                        std::swap(_size, s._size);
                        std::swap(_capacity, s._capacity);
                }

                size_t find(char c, size_t pos = 0) const
                {
                        assert(pos < _size);

                        for (int i = pos; i < _size; i++)
                                if (_str[i] == c)
                                        return i;
                        return npos;
                }

                size_t find(const char* s, size_t pos = 0) const
                {
                        const char* ret = strstr(_str + pos, s);
                        if (ret)
                                return ret - _str; // 返回下标
                        return npos;
                }

                string substr(size_t pos = 0, size_t len = npos) const
                {
                        string tmp;

                        // 全部截取
                        if (len == npos || len > _size - pos)
                        {
                                for (int i = pos; i < _size; i++)
                                        tmp += _str[i];
                        }
                        else
                        {
                                // 部分截取
                                for (int i = pos; i < pos + len; i++)
                                        tmp += _str[i];
                        }
                        return tmp;
                }

                const char* c_str() const
                {
                        return _str;
                }
        private:
                char* _str = nullptr;
                size_t _size = 0;
                size_t _capacity = 0;
        public:
                static int npos;
        };
        int string::npos = -1;

        // 全局函数
        void swap(string& s1, string& s2)
        {
                s1.swap(s2);
        }

        bool operator==(const string& s1, const string& s2)
        {
                int ret = strcmp(s1.c_str(), s2.c_str());
                return ret == 0;
        }
        
        bool operator<(const string& s1, const string& s2)
        {
                int ret = strcmp(s1.c_str(), s2.c_str());
                return ret < 0;
        }
        
        bool operator<=(const string& s1, const string& s2)
        {
                return s1 == s2 || s1 < s2;
        }
        
        bool operator>(const string& s1, const string& s2)
        {
                return !(s1 <= s2);
        }

        bool operator>=(const string& s1, const string& s2)
        {
                return !(s1 < s2);
        }

        bool operator!=(const string& s1, const string& s2)
        {
                return !(s1 == s2);
        }

        ostream& operator<<(ostream& os, const string& str)
        {
                for (auto e : str)
                        os << e;
                return os;
        }

        istream& operator>> (istream& is, string& str)
        {
                str.clear();

                char ch;
                ch = is.get();

                char buff[128];
                int i = 0;
                while (ch != ' ' && ch != '\n')
                {
                        // 字符放到buff
                        buff[i++] = ch;
                        // buff 满了，转移到string
                        if (i == 127)
                        {
                                buff[i] = '\0';
                                i = 0;
                                str += buff;
                        }
                        ch = is.get();
                }

                // 清理buff
                if (i > 0)
                {
                        buff[i] = '\0';
                        str += buff;
                }

                return is;
        }

        istream& getline(istream& is, string& str)
        {
                str.clear();

                char ch;
                ch = is.get();

                char buff[128];
                int i = 0;
                while (ch != '\n')
                {
                        // 字符放到buff
                        buff[i++] = ch;
                        // buff 满了，转移到string
                        if (i == 127)
                        {
                                buff[i] = '\0';
                                i = 0;
                                str += buff;
                        }
                        ch = is.get();
                }

                // 清理buff
                if (i > 0)
                {
                        buff[i] = '\0';
                        str += buff;
                }

                return is;
        }
}
          {
                        // 字符放到buff
                        buff[i++] = ch;
                        // buff 满了，转移到string
                        if (i == 127)
                        {
                                buff[i] = '\0';
                                i = 0;
                                str += buff;
                        }
                        ch = is.get();
                }

                // 清理buff
                if (i > 0)
                {
                        buff[i] = '\0';
                        str += buff;
                }

                return is;
        }

        istream& getline(istream& is, string& str)
        {
                str.clear();

                char ch;
                ch = is.get();

                char buff[128];
                int i = 0;
                while (ch != '\n')
                {
                        // 字符放到buff
                        buff[i++] = ch;
                        // buff 满了，转移到string
                        if (i == 127)
                        {
                                buff[i] = '\0';
                                i = 0;
                                str += buff;
                        }
                        ch = is.get();
                }

                // 清理buff
                if (i > 0)
                {
                        buff[i] = '\0';
                        str += buff;
                }

                return is;
        }
}