目录
简介
框架
构造
全缺省构造函数
编辑
传对象构造函数
拷贝构造
析构函数
容量
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;
else
return 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，后面凡是扩容都会复用reserve
for (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);
}本文到这里就结束啦
