目录
简介
框架
构造
全缺省构造函数
编辑
传对象构造函数
拷贝构造
析构函数
容量
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); }
本文到这里就结束啦