目录
简介
框架
构造
全缺省构造函数
编辑
传对象构造函数
拷贝构造
析构函数
容量
size()
capacity（）
empty()
clear()
reserve()
编辑
resize()
遍历
检引用符号"[ ]"的重载
迭代器
begin()
end()
rbegin()
rend()
修改
push_back()
"+="运算符重载
c_str
find()
其他
赋值运算符重载
现在式写法
比较运算符重载
"<"运算符重载
"="运算符重载
复用
简介
因为世界上有很多种语言，所以在STL库里有一个管理字符的模板类：basic_string模板类，而本篇要讲的string类是basic_string模板类的一个实例化，类型为char。
string类的接口设计是比较冗余的，是因为string类有一些历史包袱。在STL出现之前，就已经有string类了。在STL被惠普实验室开源之后，string类既要符合STL的标准又要向前兼容，所以string类的接口比较冗余。
string类的底层是顺序表，它在堆上开辟连续的空间，并将代码段中的常量字符串进行拷贝。通过顺序表实现对字符串的增删查改。可参考C++的动态内存管理一文：http://t.csdnimg.cn/qHEzj
小编会介绍一些常见的接口，解释它们的功能，参数。然后模拟实现一下。为了方便，小编会调用C语言库中的一些字符串操作函数。头文件string.h
模拟实现不是造一个更好的轮子，而是为了帮助我们更好的理解string类。模拟实现的代码是禁不住在各种场景下测试的，一定会出现各种bug。小编会指出一些能想的到的bug。庖丁解牛，恢恢乎游刃有余
C++是一门面向对象的语言，大家不必对每一个接口都有细致的了解。小编写本篇的目的是为了让大家能对string类的主体框架有一定的了解。让大家在查文档时游刃有余。
框架
为了让类名和接口的写法和库里的保持一致，需要封一层命名空间，名字为MyString。
数据设计：
顺序表的有效数据：size_t _size
顺序表的空间大小：size_t _capacity
指向顺序表的指针：char* _str
static const size_t npos = -1;
npos是string类中的一个静态成员变量，它表示一个无效的位置或者未找到的位置。在string类中，当查找某个子字符串或字符时，如果未找到，则返回npos。
namespace MyString //命名空间
{class string //string类
{public://接口（方法）private:size_t _size; //数据有效个数size_t _capacity; //空间大小char* _str; //指向的空间 static const size_t npos = -1; };}构造
可参考详解构造函数一文：http://t.csdnimg.cn/8Hl5K
功能：构造一个string类对象，并将其初始化
在C++11的标准中，有非常多的构造函数，如下图
模拟实现：
小编先问大家一个问题，当我们用"x\0xxx"字符串构造对象时，有效数据_size应该给成多少呢，1还是5？
可以参考一下标准库里的实现
标准库的逻辑是：在初始化对象时，以第一个"\0'为准。我们就可以调用库中的strlen(),帮我们计算一下要初始化_size的大小。strlen()计算长度时也是以第一个"\0"为准。
后面会有"x\0xxx",但_size是5的情况。因为标准库中的string类的有效数据是以_size为准，而不是以"\0"为准。这是C++的string类和C语言中字符串函数不一样的地方。
全缺省构造函数
代码如下
//全缺省构造
string(const char* str = "") :_size(strlen(str)) ,_capacity(_size + 1) ,_str(new char[_capacity])
{strcpy(_str, str);
}
传对象构造函数
代码如下
string(const string& str):_size(str._size), _capacity(str._capacity) , _str(new char[str._capacity]) {memcpy(_str, str._str, str._capacity); //这里用strcpy()拷贝会有很坑的bug}为什么小编会说用strcpy（)拷贝数据会有一个很坑的bug呢？
因为string()是以"\0"为基准作为结束条件的。而string类的顺序表可能会存放"x\0xxx"这样的字符串，数据可能会拷贝不全。
拷贝构造
可参考详解拷贝构造一文：http://t.csdnimg.cn/oJCAU
代码如下
//拷贝构造string(const string& str) {_size = str._size; //有效数据个数_capacity = str._capacity; //空间_str = new char[str._capacity]; //开空间，深拷贝 memcpy(_str, str._str, str._capacity); //这里建议用memcpy()防止中间有"\0"的问题}现在式写法，代码如下
void swap(string& s) //交换数据函数
{std::swap(_str, s._str);std::swap(_size, s._size);std::swap(_capacity, s._capacity);
}
string(const string& s) : _str(nullptr) //初始化数据,_size(0),_capacity(0)
{string Tmp(s._str); //调用构造函数构造一个与s对象一样的临时对象swap(Tmp); //调用交换函数交换两个对象
}传统写法：需要自己开空间，自己拷贝数据
现在写法：把事情交给别的函数或方法去做，具有面向对象思维
析构函数
//析构函数
~string()
{delete[] _str;_size = _capacity = 0;
}容量
size()
功能：
| 返回字符串有效长度 |
模拟实现：
size_t size() const
{return _size;
}capacity（）
功能：
| 返回string类的顺序表的空间 |
模拟实现：
size_t capacity() const
{return _capacity;
}empty()
功能：
| 判断字符串是否为空 |
模拟实现：
bool empty() const
{if (_size == 0)return true;elsereturn false;
}clear()
功能：
| 清空有效字符 |
模拟实现：
void clear()
{_str[0] = '\0';_size = 0;
}_str[0] = '\0';这句代码是为了兼容C语言的一些接口
reserve()
功能：
| 将容量调整至n |
| 此函数不会影响到字符串 |
| n大于_capacity，编译器会将容量调整到n（可能更大，不同版本的STL具体实现不同） |
| n小于或等于_capacity，编译器可能会缩容，也可能不会，不具有强制性 |
参数：
| 无符号整型n,代表要扩容的大小 |
模拟实现：
void reserve(size_t n = 0)
{if (n <= _capacity)return;char* ptr = new char[n + 1]; //开辟新空间, 多开一个是为了存放‘\0’ memcpy(ptr, _str, _size + 1); //把旧空间的值拷贝给新空间 delete[] _str; //释放旧空间 _str = ptr; //_str指向新空间 _capacity = n + 1; ptr = nullptr;
}
resize()
功能：
| 将字符串长度调整为n个字符的长度 |
| n < _size 时，删除多余字符（删掉_size - n个字符） |
| n > _size 时，会先扩容，如果指定了c，会将其初始化为字符c，没有指定，会将其初始化为"\0" |
参数：
| 无符号整型n，代表要调整字符的长度 |
| 字符型c，代表要初始化的字符 |
模拟实现：库中给了我们两个接口，但我们只需要实现一个全缺省即可
思路也很简单，只需要处理n的不同情况即可。代码如下，配有详细的注释
void resize(size_t n, char c = '\0')//c为全缺省参数，不指定c时会将新开辟的空间初始化为"\0"
{if ( n < 0) //n小于为非法值，直接返回return;if (n > _size) //n大于有效字符时，会扩容{ reserve(n); //扩容，复用reserve，后面凡是扩容都会复用reservefor (size_t i = _size; i < _capacity - 1; i++) //对开辟的空间初始化{_str[i] = c;}_str[_capacity - 1] = '\0'; //给最后一块空间赋值为\0_size = n; //不要忘了调整有效数据return;}_str[n] = '\0'; //当n小于或等于0时删数据_size = n;
}遍历
检引用符号"[ ]"的重载
功能：
| 检索第pos位置的下标 |
参数：
| 无符号整型pos，代表下标 |
返回值：
| char类型，返回string类中顺序表的的第pos位置的字符 |
模拟实现：库中给了两个，一个非成员函数，一个成员函数。代码如下
char& operator[] (size_t pos)
{assert(pos >= 0);assert(pos <= _size); //检查下标的合法性return _str[pos]; //返回顺序表中该下标的值}const char& operator[] (size_t pos) const
{assert(pos >= 0); assert(pos <= _size); return _str[pos];
}迭代器
需要把返回值的类型取别名为迭代器的通用类型，代码如下
typedef char* iterator; //正向迭代器，可修改typedef char* reverse_iterator; //反向迭代器，可修改typedef const char* const_iterator; //正向迭代器，不可修改typedef const char* const_reverse_iterator; //反向迭代器，不可修改因为string类型的底层是基于顺序表实现的，所以string类型的迭代器是指针
begin()
| 获取有效字符的第一个位置 |
iterator begin() //获取第一个字符的位置
{return _str;
}
const_iterator begin() const
{return _str;}end()
| 获取最后一个有效字符的下一个位置 |
iterator end() //最后一个字符的下一个位置
{return _str + _size;
}
const_iterator end() const
{return _str + _size;}rbegin()
| 获取最后一个有效字符的位置 |
reverse_iterator rbegin() //获取最后一个字符的位置
{return _str + _size - 1;}
const_reverse_iterator rbegin() const
{return _str + _size - 1;}rend()
| 获取第一个有效字符的前一个位置 |
reverse_iterator rend()//获取第一个字符位置的前一个位置
{return _str - 1;
}
const_reverse_iterator rend() const
{return _str - 1;}修改
push_back()
功能：
| 将字符c尾插至string类的字符串后面 |
参数：
| 字符型c，代表要尾插的字符 |
模拟实现：
void push_back(char c)
{if ((_size + 1) == _capacity || _size == _capacity) //判断是否要扩容{reserve(2 * _capacity);}_str[_size] = c; //尾插_str[_size + 1] = '\0'; //插入\0++_size; //更改有效数组的值}"+="运算符重载
功能：
| 尾插一个类的字符串 |
| 尾插一个字符串 |
| 尾插一个字符 |
返回值：
| string类的引用 |
这三类运算符重载互相构成函数重载
实现代码如下
string& operator+= (const string& str)
{size_t len = str._size + 1; if ((_size + len) >= _capacity) //扩容{reserve(2 * (_capacity + _size + len));}strcpy(_str + _size, str._str); //拷贝数据return *this; }上述代码中拷贝数据用了strcpy(),在一般场景下是没问题的。但禁不住测试，大家能调试出来吗？这个bug前文已经提过很多次了。
string& operator+= (const char* s)
{while (*s){push_back(*s);s++;}return *this;}string& operator+= (char c)
{push_back(c);return *this;}小编这里复用了push_back(),小编懒得再造轮子了（害羞）
c_str
功能：
| 返回C形式的字符串 |
模拟实现：
const char* c_str() const
{return _str;
}find()
功能：
| 查找字符串序列在string类的顺序表中第一次出现的位置 |
参数：
| string类类型的引用，表示要查找的字符串序列为string类型的顺序表 |
| 无符号整型pos，表示从哪一个下标开始找 |
| 字符型c，表示要查找的字符 |
| 字符型指针s，表示要查找的字符串 |
返回值：
| 找到：返回该位置的下标 |
| 没找到：返回npos |
模拟实现：小编只实现其中的一种
size_t find(const string& str, size_t pos = 0) const
{if (pos < 0 || pos > _size) //检查坐标合法性return npos;char* ptr = strstr(_str + pos, str._str); //strstr()是一种暴力匹配，
if (ptr == NULL)
{return npos;
}
else
{return ptr - _str;
}
}我们不是为了造更好的轮子，用strtstr()即可。
其他
赋值运算符重载
现在式写法
string& operator=(string tmp)
{swap(tmp);return *this;
}
比较运算符重载
只需实现"<"和"="即可，其他可以复用
"<"运算符重载
bool operator<(const string& s)
{size_t i = 0;size_t j = 0;while (i < _size && j < s._size)//按长度小的字符串比较{if (_str[i] < s._str[j]){return true;}else if (_str[i] > s._str[j]){return false;}else{++i;++j;}}return _size < s._size;//如果相等长度下相等，长度小的字符串就小
}"="运算符重载
bool operator==(const string& s)
{size_t i = 0;size_t j = 0;while (i < _size && j < s._size){if (_str[i] < s._str[j] || _str[i] > s._str[j]){return false;}else{++i;++j;}}return _size == s._size ? true : false;
}复用
bool operator<=(const string& s){return *this <= s; }bool operator>(const string& s){return !(*this <= s); }bool operator>=(const string& s) {return *this >= s; }bool operator!=(const string& s){return !(*this == s); }本文到这里就结束啦
