①String类的主体

②String类的具体实现

1.构造函数、拷贝构造函数、赋值运算符、析构函数

⑴构造函数

⑵拷贝构造函数

⑶赋值运算符

⑷析构函数

2.迭代器（范围for的实现原理）

3.修改:push_back, apppend, +=, clear, swap, c_str

⑴push_back

⑵apppend

⑶+=

⑷clear

⑸swap

⑹c_str

4.容量:size, capacity, empty, resize, reverse

⑴size

⑵capacity

⑶empty

⑷resize

⑸reverse

5.下标[]重载

6.逻辑运算符:<, <=, >, >=, ==, !=

7.查找:find

8.固定位置插入元素:insert

9.清除固定位置元素:erase

10.流插入、流提取运算符重载:<<, >>

⑴流插入<<

⑵流提取>>

①String类的主体

为了与库函数里面的string分开，我们将模拟实现的string类存放在自己定义的命名空间中，同时尽可能的将对应功能函数的名字与库函数一一对应，即

namespace my_string
{
    class string
    {
        friend ostream& operator<<(ostream& _cout, const my_string::string& s);
        friend istream& operator>>(istream& _cin, my_string::string& s);

    public:
        typedef char* iterator;
        typedef const char* const_iterator;
    public:
        // 构造函数
        string(const char* str = "");

        // 拷贝构造函数
        string(const string& s);

        // 赋值运算符重载
        string& operator=(const string& s);

        // 析构函数
        ~string();

        // 迭代器
        iterator begin();
        iterator end();
        const_iterator begin() const;
        const_iterator end() const;

        // 修改
        void push_back(char c);
        string& operator+=(char c);
        void append(const char* str);
        string& operator+=(const char* str);
        void clear();
        void swap(string& s);
        const char* c_str()const;

        // 容量
        size_t size()const;
        size_t capacity()const;
        bool empty()const;
        void resize(size_t n, char c = '\0');
        void reserve(size_t n);

        // 下标
        char& operator[](size_t index);
        const char& operator[](size_t index)const;

        // 逻辑运算符
        bool operator<(const string& s);
        bool operator<=(const string& s);
        bool operator>(const string& s);
        bool operator>=(const string& s);
        bool operator==(const string& s);
        bool operator!=(const string& s);

        // 返回c在string中第一次出现的位置
        size_t find(char c, size_t pos = 0) const;

        // 返回子串s在string中第一次出现的位置
        size_t find(const char* s, size_t pos = 0) const;

        // 在pos位置上插入字符c/字符串str，并返回该字符的位置
        string& insert(size_t pos, char c);
        string& insert(size_t pos, const char* str);

        // 删除pos位置上的元素，并返回该元素的下一个位置
        string& erase(size_t pos, size_t len);

    private:
        char* _str;
        size_t _capacity;
        size_t _size;
    };

};

②String类的具体实现

1.构造函数、拷贝构造函数、赋值运算符、析构函数

⑴构造函数

// 构造函数
string(const char* str = "")
{
    _size = strlen(str);
    _capacity = _size;
    _str = new char[_capacity + 1];// 字符串后有'\0'因此要+1
    memcpy(_str, str, sizeof(char) * (_size + 1));// 与上述同理
}

⑵拷贝构造函数

// 拷贝构造函数
string(const string& s)
{
    _size = s._size;
    _capacity = s._capacity;
    // 这里不能直接让_str=s._str（即浅拷贝），
    // 不然会导致两个string最后析构时对它们指向的空间析构两次
    // 此外，如果其中一个对象对这片空间的元素进行修改，会对另一个对象造成影响
    // 因此，此处只能使用深拷贝

    _str = new char[s._capacity + 1];
    memcpy(_str, s._str, sizeof(char) * (s._size + 1));
}

⑶赋值运算符

在模拟实现赋值运算符时，有两种写法，一种是与拷贝构造逻辑类似的写法，即

// 赋值运算符重载
string& operator=(const string& s)
{
    if (this != &s)// 与拷贝构造逻辑相同
    {
        _size = s._size;
        _capacity = s._capacity;
        _str = new char[s._capacity + 1];
        memcpy(_str, s._str, sizeof(char) * (s._size + 1));
    }

    return *this;
}

另一种则是通过拷贝构造一个临时对象tmp，将this与tmp所指向的空间交换，在结束时tmp还能顺便释放自己所指向的空间，即

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

// 赋值运算符重载
string& operator=(const string& s)
{
    if (this != &s)
    {
        string tmp(s);
        swap(tmp);
    }

    return *this;
}

图示如下

从图中我们可以明显看出，在此函数调用完后，tmp也会顺带将s1先前所指向的空间释放

⑷析构函数

// 析构函数
~string()
{
    _size = _capacity = 0;
    delete[] _str;
    _str = nullptr;
}

2.迭代器（范围for的实现原理）

从string类的主体中我们不难看出，string类的迭代器其实就是指针，即

这是因为string类的对象本身处在一个连续的空间内，可以直接通过指针来操控，因此我们便可以得到

// 迭代器
iterator begin()
{
    return _str;
}

iterator end()
{
    return _str + _size;
}

const_iterator begin() const
{
    return _str;
}

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

在这里我们可以看看范围for是如何做到的，首先我们直接使用有

而当我们将任意一个迭代器(begin或end注释掉后可以发现)

因此我们可以发现，其实所谓的范围for不过就是将这段代码固定的替换成如下这段代码

my_string::string::iterator it = s.begin();
while (it != s.end())
{
	cout << *it;
	it++;
}

而且范围for只会固定的寻找end和begin名字的迭代器，略微修改名字也会报错