①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'因此要+1memcpy(_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名字的迭代器，略微修改名字也会报错