通过上篇我们已经学习到了string类的基本使用，这里我们就试着模拟实现一些，我们主要实现一些常用到的函数。
注意：我们在此实现的和C++标准库中实现的有所不同，其目的主要是帮助大家大概理解底层原理。本篇中涉及许多的字符串函数，大家如果不清楚具体功能的可以先看一下这篇文章 -> 常见的字符串函数
我们模拟string类的大致框架是：
class string
{
public://...private:char* _str;size_t _size;size_t _capacity;
};_str是在堆上动态开辟的空间，_size是元素个数，_capacity是容量大小。 接下来主要是实现一些public下的一些内容。
一、构造函数
在这里我们只实现两个常用的构造函数，一个是默认构造，一个是带参构造。
string():_str(nullptr),_size(0),_capacity(0)
{}
string(const char* str)
{_size = strlen(str);_capacity = _size; //_capacity不包含'\0'，所以不用+1_str = new char[_capacity + 1]; //+1是为了存放'\0'strcpy(_str, str);
}大家仔细看看，默认构造写的对吗？
乍一看，没有任何问题，如果打印可以看到的是空串就说明我们写的是对的。
因为我们还没实现重载流插入和流提取，所以我们可以简单的写一个c_str()来帮助我们打印。
const char* c_str() const
{return _str;
}在主函数中调用test_string1()：
void test_string1()
{string s1;string s2("hello world");cout << s1.c_str() << endl;cout << s2.c_str() << endl;
}运行结果：
我们发现程序崩了，这说明我们写的有问题，其原因是因为在默认构造函数中_str初始化为空指针nullptr， 在打印过程中，在字符串必须要找到'\0'才终止，而对nullptr进行解引用程序就会出现崩溃。
我们可以这样写：
string():_str(new char[1]{ '\0' }),_size(0),_capacity(0)
{}运行结果：
注意： _str(new char[1]{ '\0' }) 和 _str(new char('\0'))这两种写法的效果一样，但要写成前者的形式，其目的是为了适应析构函数。
我们也可以将上边两个构造函数合并成一个：
string(const char* str = "")
{_size = strlen(str);_capacity = _size; //_capacity不包含'\0'，所以不用+1_str = new char[_capacity + 1]; //+1是为了存放'\0'strcpy(_str, str);
}二、析构函数
直接看代码即可：
~string()
{delete[] _str;_str = nullptr;_size = _capacity = 0;
}三、赋值重载
string& operator=(const string& str)
{if(this != &str) //防止自己给自己赋值{delete[] _str; //先释放旧空间，否则会造成内存泄漏_str = new char[str._size + 1];strcpy(_str,str._str);_size = str._size;_capacity = str._capacity;}return *this;
}四、拷贝构造
拷贝构造在"五(11)"引出。
五、成员函数
(1)size()/capacity()
//返回字符串中元素个数
size_t size() const
{return _size;
}//返回所开空间的容量大小(比实际空间少1，1就是'\0')
size_t capacity() const
{return _capacity;
}这种简单的代码，大家一看便知，不过多赘述。
(2)重载[]
//返回下标为pos位置上的字符
char& operator[](size_t pos)
{assert(pos >= 0 && pos < _size); //越界直接报错return _str[pos];
}这里需要注意的是返回值要用引用返回，其一，它的空间申请在堆上，调用[]后，对象不销毁，所用可以使用引用返回。其二，我们可以修改pos下标的值，即可读可写。
还有一种写法：
//返回const类型字符串下标为pos位置上的字符
const char& operator[](size_t pos) const
{assert(pos >= 0 && pos < _size); //越界直接报错return _str[pos];
}这种写法只能读不能写，也就是不能修改pos下标的值。
调用assert函数必须包含头文件<assert.h>。
(3)迭代器
我们在上篇文章中提到迭代器的功能像指针，所以在这里可以用指针的方式定义迭代器。
typedef char* iterator;//返回起始位置指针
iterator begin()
{return _str;
}//返回最后一个有效字符位置的下一位置的指针
iterator end()
{return _str + _size;
}在主函数中调用test_string2()：
void test_string2()
{string s1("good morning");string::iterator it = s1.begin();while (it != s1.end()){cout << *it << " ";++it;}cout << endl;
}运行结果：
我们这里用原生指针来typedef迭代器，根本原因是string的底层是数组，我们才可以这样玩，如果底层是链表这样定义的方式就不行了。
迭代器是一种封装的体现。它屏蔽了底层结构和实现细节，提供了统一的类似访问容器的方式。
const迭代器：
typedef const char* const_iterator;//返回const类型字符串的起始位置指针
const_iterator cbegin() const
{return _str;
}//返回const类型字符串的最后一个有效位置的下一位置的指针
const_iterator cend() const
{return _str + _size;
}(4)reserve()
//设置容量
void reserve(size_t n)
{if (n > _capacity){char* tmp = new char[n + 1]; //加1是为了存放'\0'strcpy(tmp, _str);delete[] _str;_str = tmp;_capacity = n;}
}n比原先容量大就扩容，在C++中我们尽量不要去使用C语言中的realloc去扩容，要使用new这个关键字来扩容。
n比原先容量小是否缩容是不确定的，我们这里就不处理这种情况了。
(5)push_back()
//在字符串最后位置上插入一个字符
void push_back(char ch)
{if (_size == _capacity){//扩容reserve(_capacity == 0 ? 4 : _capacity * 2);}_str[_size] = ch;_size++;
}这里只实现了尾插一个字符这一个重载函数。
在主函数中调用test_string3()：
void test_string3()
{string s1("hello world");s1.push_back('x');s1.push_back('x');cout << s1.c_str() << endl;
}运行结果：
这结果怎么和我们想象的不太一样？ 怎么出现乱码了
这是因为我们没有考虑'\0'，我们在尾插时覆盖掉了末尾的'\0'，导致出现乱码。
更改后的代码：
void push_back(char ch)
{if (_size == _capacity){//扩容reserve(_capacity == 0 ? 4 : _capacity * 2);}_str[_size] = ch;_size++;_str[_size] = '\0'; //防止'\0'被覆盖
}(6)重载+=
//在字符串最后位置上接一个字符
string& operator+=(char ch)
{push_back(ch);return *this;
}这里直接复用push_back，就可以达到效果。
在主函数中调用test_string4()：
void test_string3()
{string s1("hello world");s1 += 'x';s1 += 'x';cout << s1.c_str() << endl;
}运行结果：
这里我们调用了修改后的push_back()，所以没有出现乱码，如果我们自己实现就要提防出现乱码的情况。
这里通常也会+=一个字符串(我们可以复用下面append函数)：
//在字符串最后位置上接一个字符串
string& operator+=(const char* str)
{append(str);return *this;
}(7)append()
//在字符串最后位置上追加一个字符串
void append(const char* str)
{size_t len = strlen(str);if (_size + len > _capacity){//扩容//大于2倍，需要多少开多少，不足2倍，按二倍扩reserve(_size + len > 2 * _capacity ? _size + len : 2 * _capacity);}strcpy(_str + _size, str); //这里不用担心'\0'问题，因为strcpy也会把'\0'拷贝进去_size += len;
}append在扩容时不能直接固定2倍扩，因为追加的字符串的长度可能大于capacity的2倍，我们这里采用了如果_size + len大于2倍_capacity，需要多少开多少，不足2倍，按二倍扩。
(8)insert()
//在pos位置前插入一个字符
void insert(size_t pos, char ch)
{assert(pos <= _size);if (_size == _capacity){//扩容reserve(_capacity * 2 == 0 ? 4 : _capacity * 2);}//挪动数据size_t end = _size;while (end >= pos){_str[end + 1] = _str[end];--end;}_str[pos] = ch;++_size;
}代码写起来飞快，但有没有错误呢？
我们来验证一下， 在主函数中调用test_string5()：
void test_string5()
{string s("hello world");cout << s.c_str() << endl;s.insert(0, 'x'); //头插cout << s.c_str() << endl;}运行结果：
这里程序崩了，这又是哪里出问题了呢？
这是循环的跳出条件是end>=pos，正常情况下end==0是最后一次进入循环，然后end-1 == -1后大于0，就跳出循环，但由于这里end是size_t无符号整形，所以它永远不可能是-1，所以程序崩溃。那我们把end类型改为int不就行了 ，答案也是不行，因为pos是size_t类型，一个int类型和size_t类型进行比较时，会隐式类型提升，将int默默提升为size_t类型进行比较，所以我们要将pos强制转换成int类型进行比较。
修改后的代码：
//在pos位置前插入一个字符
void insert(size_t pos, char ch)
{assert(pos <= _size);if (_size == _capacity){//扩容reserve(_capacity * 2 == 0 ? 4 : _capacity * 2);}//挪动数据int end = _size; //必须将end类型改为intwhile (end >= (int)pos) //比较时必须将pos类型强制转换为int{_str[end + 1] = _str[end];--end;}_str[pos] = ch;++_size;
}运行结果：
还有另外一种写法：
//在pos位置前插入一个字符
void insert(size_t pos, char ch)
{assert(pos <= _size);if (_size == _capacity){//扩容reserve(_capacity * 2 == 0 ? 4 : _capacity * 2);}//挪动数据size_t end = _size + 1;while (end > pos){_str[end] = _str[end - 1];--end;}_str[pos] = ch;++_size;
}这种写法会更好一点。
上面写的是插入一个字符，接下来我们实现插入一个字符串：
//在pos位置前插入一个字符串
void insert(size_t pos, const char* str)
{assert(pos < _size);size_t len = strlen(str);if (_size + len > _capacity){//扩容//大于2倍，需要多少开多少，不足2倍，按二倍扩reserve(_size + len > 2 * _capacity ? _size + len : 2 * _capacity);}size_t end = _size + len;while (end >= pos + len){_str[end] = _str[end - len];--end;}for (size_t i = 0;i < len;++i){_str[pos + i] = str[i];}_size += len;
}这段代码有一种情况也会出现问题，就是pos和len同时为0，按理说这是没意义的，但这种情况确实存在，故我们要预防这种情况，添加一个if判断即可：
void insert(size_t pos, const char* str)
{assert(pos < _size);size_t len = strlen(str);if (len == 0) //这里判断一下特殊的情况return;if (_size + len > _capacity){//扩容//大于2倍，需要多少开多少，不足2倍，按二倍扩reserve(_size + len > 2 * _capacity ? _size + len : 2 * _capacity);}size_t end = _size + len;while (end >= pos + len){_str[end] = _str[end - len];--end;}for (size_t i = 0;i < len;++i){_str[pos + i] = str[i];}_size += len;
}(9)erase()
//从pos位置开始，向后删除len个字符
void erase(size_t pos, size_t len)
{assert(pos < _size); if (len > _size - pos) //删除pos往后的所有字符{_str[pos] = '\0';_size = pos;}else{for (size_t i = pos + len;i <= _size; ++i){_str[i - len] = _str[i];}_size -= len;}
}在主函数中调用test_string6()：
void test_string6()
{string s("hello world");cout << s.c_str() << endl;s.erase(0, 6);cout << s.c_str() << endl;
}运行结果：
(10)find()
//从pos位置向后查找，找到第一个字符ch返回其下标，否则返回npos
size_t find(char ch, size_t pos)
{assert(pos < _size);for (size_t i = pos;i < _size;i++){if (_str[i] == ch)return i;}return npos; //static const size_t npos = -1
}下面是上面的一个重载函数：
//从pos位置向后查找，找到第一个字串str返回其首个字符的下标，否则返回npos
size_t find(const char* str, size_t pos)
{assert(pos < _size);const char* ptr = strstr(_str + pos, str); //如果找到字串，返回母串中子串的起始位置的指针if (ptr== nullptr){return npos;}else{return ptr - _str;}
}(11)substr()
//取子串
string substr(size_t pos, size_t len)
{assert(pos < _size);//len大于剩余字符长度，更新一下lenif (len > _size - pos){len = _size - pos;}string sub; //用来存放字串sub.reserve(len); //提前预留出空间，避免频繁扩容for (size_t i = 0; i < len; ++i){sub += _str[pos + i];}return sub;
}在主函数中调用test_string7()：
void test_string7()
{string s("Test.txt");size_t pos = s.find('.');string tmp = s.substr(pos,npos); //static const size_t npos = -1;cout << tmp.c_str() << endl;
}运行结果：
程序崩溃，打印了一串乱码，肯定是我们的程序写的有点问题。
从代码中看，因为不能写传引用返回，所以我们写的是传值拷贝，传值返回会调用拷贝构造，我们此刻没有写拷贝构造，所以会调用默认生成的拷贝构造完成浅拷贝，问题就出在这个浅拷贝身上，如果是浅拷贝，调用结束后sub指向的空间就被收回了，而由于是浅拷贝tmp的_str又指向被收回的空间，所以会造成非法访问内存空间。导致打印一串乱码，程序崩溃。
所以我们要想解决这个问题就需要单独写一个拷贝构造，来进行深拷贝。
//拷贝构造 -- 深拷贝
string(const string& str)
{_str = new char[str._capacity + 1];strcpy(_str, str._str);_size = str._size;_capacity = str._capacity;
}再次运行：
这次代码正常运行。
(12)swap()
swap函数写起来非常简单，只需要调用库中swap即可。
库中的swap是一个模板，我们成员函数swap实现如下：
void swap(string& tmp)
{std::swap(_str, tmp._str);std::swap(_size, tmp._size);std::swap(_capacity, tmp._capacity);
}很容易明白。
六、非成员函数
(1)重载关系运算符
bool operator<(const string& s1, const string& s2)
{return strcmp(s1.c_str(), s2.c_str()) < 0;
}
bool operator==(const string& s1, const string& s2)
{return strcmp(s1.c_str(), s2.c_str()) == 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);
}我们只需重载<和==，其余运算符重载直接复用它们两个即可实现。
在主函数中调用test_string8()：
void test_string8()
{string s1("Hello");string s2("Hello");cout << (s1 == s2) << endl;cout << (s1 > s2) << endl;cout << (s1 < s2) << endl;cout << (s1 == "Hello") << endl; //隐式类型转换cout << ("world" == "Hello") << endl; //重载的条件必须满足至少一个是自定义类型，这里是两个const类型的char指针在比较
}运行结果：
(2) 重载流插入(<<)和流提取(>>)
ostream& operator<<(ostream& out, const string& str)
{for (auto e : str){out << e;}return out;
}
istream& operator>>(istream& in, string& str)
{char ch;in >> ch;while (ch != ' ' && ch != '\n'){str += ch;in >> ch;}return in;
}在主函数中调用test_string9()：
void test_string9()
{string s1;cin >> s1;cout << s1;
}运行结果：
我们发现遇到空格或换行，程序并没有终止，也就是cin还在进行，初步判断问题出在重载流提取>>时出现了错误。
原因是cin在控制台拿数据时，会将空格和换行认为是分隔符，会读空格和换行但仅仅认为它们是分隔符，也就是取不到空格和换行。所以，界面就会一直等待输出，循环出不来。换成get可以解决问题，get是什么字符都可以取到。在C语言中scanf和cin一样，也是取不到空格和换行，可以换成getchar来解决问题。
修改后代码：
istream& operator>>(istream& in, string& str)
{char ch;ch = in.get(); //调用get是什么字符就接收什么字符，不会过滤掉空格while (ch != ' ' && ch != '\n'){str += ch;ch = in.get();}return in;
}在主函数中调用test_string10()：
void test_string10()
{string s1("hello world");cin >> s1;cout << s1;
}运行结果：
不对呀，这结果怎么是这样的？
因为s1是有内容的，所以在调用流提取>>时，要先将对象中的内容清空，代码如下：
void clear()
{_str[0] = '\0';_size = 0;
}istream& operator>>(istream& in, string& str)
{str.clear();char ch;ch = in.get(); //调用get是什么字符就接收什么字符，不会过滤掉空格while (ch != ' ' && ch != '\n'){str += ch;ch = in.get();}return in;
}运行结果：
这样就完成了重载流提取>>的工作。
优化流提取>>:
调用>>，当我们插入大量字符时，会不断的进行+=，会造成频繁扩容，会损耗性能。
这里进行优化：
istream& operator>>(istream& in, string& str)
{str.clear();const int N = 256;char buff[N]; //作为缓冲int i = 0;char ch;ch = in.get(); //调用get是什么字符就接收什么字符，不会过滤掉空格while (ch != ' ' && ch != '\n'){buff[i++] = ch;if (i == N - 1){buff[i] = '\0';str += buff;i = 0;}ch = in.get();}if (i > 0) //没进if语句{buff[i] = '\0';str += buff;}return in;
}这个代码的好处是：如果输入很长的字符串不会频繁扩容，如果输入很短的字符串，影响也不大，因为我的buff是在栈中开辟的，调用完就销毁了，对程序的性能影响不大。
(3)getline()
getline的功能和流提取>>差不多，区别是getline遇到空格不结束，遇到换行才结束。
我们稍作修改即可实现：
istream& getlien(istream& in, string& str)
{str.clear();char ch;ch = in.get(); //调用get是什么字符就接收什么字符，不会过滤掉空格while (ch != '\n'){str += ch;ch = in.get();}return in;
}(4)swap()
在上面有一个swap成员函数，但在这里它不是成员函数，它是针对string类型全局函数。为什么又有了一个？
我们先看一个例子：
void test_string12()
{string s1("hello");string s2("world");//方式1s1.swap(s2);//方式2swap(s1, s2);
}方式1会调用这个：
void swap(string& tmp)
{std::swap(_str, tmp._str); //这里的sawp也是全局的模板swap，但交换的是内置类型std::swap(_size, tmp._size);std::swap(_capacity, tmp._capacity);
}方式2会调用这个：
template <class T> void swap ( T& a, T& b )
{T c(a); a=b; b=c;
}在C++98下，肯定是方式1好些，因为string类型的对象调用方式2，首先完成一次拷贝构造，接着两次赋值重载，相当于比方式1多了3次深拷贝，这代价是很大了，每次都要开空间，效率是很低的。
为什么方式1没有拷贝呢？虽然方式1中也调用了模板swap，但参数都是内置类型，所以没有拷贝，效率比较高，所以方式1会更好。
其实，C++也考虑到了这点，他也写了一个全局swap函数：
它是将模板实例化了，变成具体的函数。
我们以方式2去写，它其实调的是void swap (string& x, string& y)这个函数，不再去单独调用模板了，而这个函数内部调用的x.swap(y)，相当于方式1的用法，也不会有拷贝了。也解决了3次深拷贝的问题。
七、形式
(1)拷贝构造又一形式
我们在实现拷贝构造的时候是我们手动来进行开辟空间，赋值等一系列操作完成深拷贝，但还有一种方法可以帮助我们达到目的，而且不用我们手动开辟空间：
void swap(string& tmp)
{//交换成员变量std::swap(_str, tmp._str); //这里需要用到标准库中的swap来进行交换std::swap(_size, tmp._size);std::swap(_capacity, tmp._capacity);
}
string(const string& str)
{string tmp(str.c_str());swap(tmp);
}我们在拷贝构造中，先定义一个临时的string对象tmp，tmp相当于str的一份拷贝，再将当前的对象的成员变量与tmp的成员变量进行交换，即可实现间接拷贝，来达到目的。
这里需要注意一个点，就是要保证当前对象的_str的值为nullptr，因为一会要交换给tmp，tmp出作用域会销毁，所以要保证当前的_str不是随机值，我们可以在声明成员函数是给一个缺省值：
char* _str = nullptr;
size_t _size = 0;
size_t _capacity = 0;(2)赋值重载又一形式
赋值重载与拷贝构造的思路差不多，我们直接看代码：
void swap(string& tmp)
{//交换成员变量std::swap(_str, tmp._str); //这里需要用到标准库中的swap来进行交换std::swap(_size, tmp._size);std::swap(_capacity, tmp._capacity);
}
string& operator=(const string& str)
{if (this != &str){string tmp(str.c_str());swap(tmp);}return *this;
}这里就很巧妙了，赋值重载，假设s2 = s1，我们之前在实现赋值重载时，是先把s2所占空间释放掉，再开辟和s1一样大的空间，再调用strcpy进行复制，现在我们这样写就不用手动释放s2的空间了，交换之后，tmp就是之前s2，出了作用域，tmp自动调用析构函数，进行空间释放，所以这段代码的妙处就在于，既完成了赋值，又完成了对之前空间的释放。
再简洁：
string& operator=(string tmp)
{swap(tmp);return *this;
}我们也可以直接进行交换，以s2 = s1为例，tmp是s1的拷贝构造出来的对象，它们的_str是不一样的，但_str指向的内容是一样的。然后交换，和上面一样的思路。这种写法更简洁，也能达到目的。
(3)优点
以上这些写法，在效率上与之前的相比没有优劣之分，它们思路不同，之前的是我们手动设置容量，现在这些活全部交给编译器去完成了，减少了我们出错的机会。
我们可以写一段代码来检验我们说的到底对不对，到底能不能实现功能。
在主函数中调用test_string11()：
void test_string11()
{string s1("hello world");string s2 = s1; //调用拷贝构造string s3("hah");s1 = s3;//调用赋值重载cout << s2 << endl;cout << s1 << endl;
}运行结果：
结果没有任何问题。 当然大家可以多测试几组(下面有源码)，这里我就不多测了，应该是没问题的。
八、写时拷贝(了解)
我们在浅拷贝时会遇到一些问题：
- 析构两次
- 一个修改会影响另外一个
那么如何解决这些问题？
这里引出来一个引用计数的概念：
引用计数：用来记录资源使用者的个数。在构造时，将资源的计数给成1，每增加一个对象使用该
资源，就给计数增加1，当某个对象被销毁时，先给该计数减1，然后再检查是否需要释放资源，
如果减1后计数为0，说明该对象时资源的最后一个使用者，将该资源释放；否则就不能释放，因为还有其他对象在使用该资源。
通过引用计数我们就解决了析构多次的问题。
如果引用计数是1，那么我可以任意修改，因为空间只有我一人掌管。
如果引用计数不是1，那么我还是要进行深拷贝，"引用计数和写时拷贝"，也就是说谁写，谁拷贝。
这时候，有些人会认为直接深拷贝就行了，不用引用计数不是也可以嘛。
这里有一个"博弈"的思想：如果拷贝后，不写就是"赚"。
如果博弈成功，将会提高代码执行的效率。一般在vs上用的是深拷贝，在g++上用的是写时拷贝。
九、源码
(1)string.h
#pragma once
#include <string>
#include <assert.h>
#include <iostream>
using namespace std;namespace blue
{class string{public:typedef char* iterator;iterator begin(){return _str;}iterator end(){return _str + _size;}iterator begin() const{return _str;}iterator end() const{return _str + _size;}typedef const char* const_iterator;const_iterator cbegin() const{return _str;}const_iterator cend() const{return _str + _size;}//短小频繁调用的函数可以直接定义到类中，默认是inlinestring(const char* str = ""){_size = strlen(str);_capacity = _size; //_capacity不包含'\0'，所以不用+1_str = new char[_capacity + 1]; //+1是为了存放'\0'strcpy(_str, str);}~string(){delete[] _str;_str = nullptr;_size = _capacity = 0;}/*string(const string& str){_str = new char[str._capacity + 1];strcpy(_str, str._str);_size = str._size;_capacity = str._capacity;}*/void swap(string& tmp){std::swap(_str, tmp._str);std::swap(_size, tmp._size);std::swap(_capacity, tmp._capacity);}string(const string& str){string tmp(str.c_str());swap(tmp);}//赋值重载//string& operator=(const string& str)//{// if (this != &str)// {// delete[] _str; //先释放旧空间，否则会造成内存泄漏// _str = new char[str._size + 1];// strcpy(_str, str._str);// _size = str._size;// _capacity = str._capacity;// }// return *this;//}//string& operator=(const string& str)//{// if (this != &str)// {// string tmp(str.c_str());// swap(tmp);// }// return *this;//}string& operator=(string tmp){swap(tmp);return *this;}const char* c_str() const{return _str;}size_t size() const{return _size;}size_t capacity() const{return _capacity;}char& operator[](size_t pos){assert(pos >= 0 && pos < _size); //越界直接报错return _str[pos];}const char& operator[](size_t pos) const{assert(pos >= 0 && pos < _size); //越界直接报错return _str[pos];}void clear(){_str[0] = '\0';_size = 0;}void reserve(size_t n);void push_back(char ch);void append(const char* str);string& operator+=(char ch);string& operator+=(const char* str);void insert(size_t pos,char ch);void insert(size_t pos,const char* str);void erase(size_t pos,size_t len = npos);size_t find(char ch, size_t pos = 0);size_t find(const char* str, size_t pos = 0);string substr(size_t pos = 0, size_t len = npos);private:char* _str = nullptr;size_t _size = 0;size_t _capacity = 0;//static const size_t npos = -1;//static const double d = 1.1;//errstatic const size_t npos;};bool operator<(const string& s1, const string& s2);bool operator==(const string& s1, const string& s2);bool operator<=(const string& s1, const string& s2);bool operator>(const string& s1, const string& s2);bool operator>=(const string& s1, const string& s2);bool operator!=(const string& s1, const string& s2);ostream& operator<<(ostream& out, const string& str);istream& operator>>(istream& in, string& str);}(2)string.cpp
#include "string.h"namespace blue
{const size_t string::npos = -1;//设置容量void string::reserve(size_t n){if (n > _capacity){char* tmp = new char[n + 1];strcpy(tmp, _str);delete[] _str;_str = tmp;_capacity = n;}}//在字符串最后位置上插入一个字符void string::push_back(char ch){if (_size == _capacity){//扩容reserve(_capacity == 0 ? 4 : _capacity * 2);}_str[_size] = ch;_size++;_str[_size] = '\0';}//在字符串最后位置上追加一个字符串void string::append(const char* str){size_t len = strlen(str);if (_size + len > _capacity){//扩容//大于2倍，需要多少开多少，不足2倍，按二倍扩reserve(_size + len > 2 * _capacity ? _size + len : 2 * _capacity);}strcpy(_str + _size, str);_size += len;}//在字符串最后位置上接一个字符string& string::operator+=(char ch){push_back(ch);return *this;}//在字符串最后位置上接一个字符串string& string::operator+=(const char* str){append(str);return *this;}//在pos位置前插入一个字符void string::insert(size_t pos, char ch){assert(pos <= _size);if (_size == _capacity){//扩容reserve(_capacity * 2 == 0 ? 4 : _capacity * 2);}//挪动数据//int end = _size; //必须将end类型改为int//while (end >= (int)pos) //比较时必须将pos类型强制转换为int//{// _str[end + 1] = _str[end];// --end;//}size_t end = _size + 1;while (end > pos){_str[end] = _str[end - 1];--end;}_str[pos] = ch;++_size;}//在pos位置前插入一个字符串void string::insert(size_t pos, const char* str){assert(pos < _size);size_t len = strlen(str);if (len == 0) //这里判断一下特殊的情况return;if (_size + len > _capacity){//扩容//大于2倍，需要多少开多少，不足2倍，按二倍扩reserve(_size + len > 2 * _capacity ? _size + len : 2 * _capacity);}size_t end = _size + len;while (end >= pos + len){_str[end] = _str[end - len];--end;}for (size_t i = 0;i < len;++i){_str[pos + i] = str[i];}_size += len;}//从pos位置开始，向后删除len个字符void string::erase(size_t pos, size_t len){assert(pos < _size);if (len > _size - pos){_str[pos] = '\0';_size = pos;}else{for (size_t i = pos + len;i <= _size; ++i){_str[i - len] = _str[i];}_size -= len;}}//从pos位置向后查找，找到第一个ch返回其下标，否则返回npossize_t string::find(char ch, size_t pos){assert(pos < _size);for (size_t i = pos;i < _size;i++){if (_str[i] == ch)return i;}return npos; //static const size_t npos = -1}size_t string::find(const char* str, size_t pos){assert(pos < _size);const char* ptr = strstr(_str + pos, str); //如果找到字串，返回母串中子串的起始位置的指针if (ptr == nullptr){return npos;}else{return ptr - _str;}}//取子串string string::substr(size_t pos, size_t len){assert(pos < _size);//len大于剩余字符长度，更新一下lenif (len > _size - pos){len = _size - pos;}string sub; //用来存放字串sub.reserve(len); //提前预留出空间，避免频繁扩容for (size_t i = 0; i < len; ++i){sub += _str[pos + i];}return sub;}bool operator<(const string& s1, const string& s2){return strcmp(s1.c_str(), s2.c_str()) < 0;} bool operator==(const string& s1, const string& s2){return strcmp(s1.c_str(), s2.c_str()) == 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& out, const string& str){for (auto e : str){out << e;}return out;}//istream& operator>>(istream& in, string& str)//{// str.clear();// char ch;// //in >> ch;// ch = in.get(); //调用get是什么字符就接收什么字符，不会过滤掉空格// while (ch != ' ' && ch != '\n')// {// str += ch;// //in >> ch;// ch = in.get();// }// return in;//}istream& operator>>(istream& in, string& str){str.clear();const int N = 256;char buff[N]; //作为缓冲int i = 0;char ch;ch = in.get(); //调用get是什么字符就接收什么字符，不会过滤掉空格while (ch != ' ' && ch != '\n'){buff[i++] = ch;if (i == N - 1){buff[i] = '\0';str += buff;i = 0;}ch = in.get();}if (i > 0) //没进if语句{buff[i] = '\0';str += buff;}return in;}
}(3)Test.cpp
#include "string.h"namespace blue
{void test_string1(){//string s1;//string s2("hello world");//cout << s1.c_str() << endl;//cout << s2.c_str() << endl;string s3("good morning");string::iterator it = s3.begin();while (it != s3.end()){cout << *it << " ";++it;}cout << endl;}void test_string2(){string s1("good morning");string::iterator it = s1.begin();while (it != s1.end()){cout << *it << " ";++it;}cout << endl;}void test_string3(){string s1("hello world");s1.push_back('x');s1.push_back('x');cout << s1.c_str() << endl;}void test_string4(){string s1("hello world");s1 += 'x';s1 += 'x';cout << s1.c_str() << endl;}void test_string5(){string s("hello world");cout << s.c_str() << endl;s.insert(0, 'x');cout << s.c_str() << endl;}void test_string6(){string s("hello world");cout << s.c_str() << endl;s.erase(0, 6);cout << s.c_str() << endl;}void test_string7(){string s("Test.txt");size_t pos = s.find('.');string sub = s.substr(pos); cout << sub.c_str() << endl;}void test_string8(){string s1("Hello");string s2("Hello");cout << (s1 == s2) << endl;cout << (s1 > s2) << endl;cout << (s1 < s2) << endl;cout << (s1 == "Hello") << endl; //隐式类型转换cout << ("world" == "Hello") << endl; //重载的条件必须满足至少一个是自定义类型，这里是两个const类型的char指针在比较}void test_string9(){string s1;cin >> s1;cout << s1;}void test_string10(){string s1("hello world");cin >> s1;cout << s1;}void test_string11(){string s1("hello world");string s2 = s1; //调用拷贝构造string s3("hah");s1 = s3;//调用赋值重载cout << s2 << endl;cout << s1 << endl;}void test_string12(){string s1("hello");string s2("world");//方式1s1.swap(s2);//方式2swap(s1, s2);}
}int main()
{//blue::test_string1();//blue::test_string2();//blue::test_string3();//blue::test_string4();//blue::test_string5();//blue::test_string6();//blue::test_string7();//blue::test_string8();//blue::test_string9();//blue::test_string10();blue::test_string11();return 0;
}在外面套了一个命名空间blue是为了防止与C++标准库中string发生冲突。
十、结语
本篇内容到这里就结束了，主要讲了string的模拟实现的大致思路，希望帮助到大家，祝大家天天开心！
