目录
前言
string是我们在学习C++的过程中不可避免要遇到的一个类，string主要处理字符串，围绕着字符串有着这样和那样的功能。实际上string有很多的功能函数，但是有些函数实用价值并不算太高，因此我们在模拟的时候会重点关注一些使用率较高的函数。
string类的成员变量
首先，string是可以用来存放字符串的，因此会有 char* _str 指针变量。为了实现对字符串的一系列增删查改，我们需要动态开辟空间来存储字符串，因此也就涉及到了_str指针变量所指向空间的大小_capacity和字符串的长度_size。
class string
{
private:
char* _str;
size_t _size;
size_t _capacity;
}string类的成员函数
构造函数
string(const char* str="") //这里相当于缺省参数，解决无参实例化的应用场景
:_size(strlen(str))
,_capacity(_size)
{
_str = new char[_capacity + 1]; //多开一个字节的空间是为了存放'\0'
strcpy(_str, str);
}析构函数
~string()
{
if (_str) //非空字符串就进行空间释放
{
delete[] _str;
_str = nullptr;
}
}拷贝构造函数
写法一：老老实实开空间，将字符串拷贝过去。
string(const string& s)
{
_size = s._size;
_capacity = s._capacity;
_str = new char[_capacity + 1];
strcpy(_str, s._str);
}写法二：偷窃法，先用构造函数创建一个对象tmp，再用swap函数将this的三个变量与tmp的三个变量交换，最后出了拷贝构造函数再把tmp析构掉。实际上相当于复用构造函数了（推荐）。
string(const string& s)
{
string tmp(s._str);
std::swap(_str, tmp._str);
std::swap(_size, tmp._size);
std::swap(_capacity, tmp._capacity);
}返回字符串大小函数
size_t size()const
{
return _size;
}返回对象空间大小函数
size_t capacity()const
{
return _capacity;
}判断对象是否为空函数
bool empty()const
{
return !_size;
}改动空间大小的函数
reverse函数
这个函数只会判断原空间是否大于你现在所要的空间，如果空间不够的话就重新开辟，空间够的话就什么都不做。
void reverse(size_t n)
{
if (n > _capacity)
{
_capacity = n;
char* tmp = new char[_capacity + 1];
strcpy(tmp, _str);
delete[] _str; //注意要把之前的空间给释放掉，防止内存泄漏
_str = tmp;
}
}resize函数
注意区分reverse函数与resize函数，resize函数除了能够像reverse函数一样扩容，还能实现“缩容”。这里的缩容并不是指把空间给变小了，而是把_size变小了。
而在这里也有一个特殊情况，就是扩容的时候支持把新扩容的空间赋值成想要的字符，缺省值为'\0'。
void resize(size_t n, const char c = '\0')
{
if (n < _size)
{
_size = n;
_str[_size] = '\0';
}
else
{
if (n > _capacity)
{
reverse(n);
}
for (size_t i = _size; i < n; i++)
{
_str[i] = c;
}
_size = n; //重置_size
_str[_size] = '\0'; //最后的一个字符后面一定是'\0'
}
}任意位置插入删除函数
insert函数
1.单个字符的插入
图解：
代码实现：
string& insert(size_t pos, const char c)
{
assert(pos <= _size);//插入位置不能越界
reverse(_size + 1);//检查空间，不够的话扩容
for (size_t i = _size + 1; i > pos; --i) //从'\0'之后开始一个字符一个字符的往后挪动
{
_str[i] = _str[i - 1];
}
_str[pos] = c;
_size += 1;
return *this;
}2.插入字符串
图解：
代码实现：
string& insert(size_t pos, const char* str)
{
assert(pos <= _size);//判断插入位置合法
size_t len = strlen(str);
reverse(_size + len);
for (size_t i = _size + len; i > pos + len - 1; --i)
{
_str[i] = _str[i - len];
}
for (size_t i = 0; i < len; i++)
{
_str[i + pos] = str[i];
}
_size += len;
return *this;
}erase函数
从pos位置起删除len个字符
图解：
代码实现：
string& erase(size_t pos, size_t len)
{
assert(pos <= _size);
if (len >= _size - pos)
{
_size = pos;
_str[_size] = '\0';
}
else
{
for (size_t i = 0; i < _size - pos - len + 1; ++i)
{
_str[pos + i] = _str[pos + i + len];
}
_size -= len;
}
return *this;
}
尾插函数
push_back函数
尾插一个字符
//正常实现代码
void push_back(const char c)
{
if (_size == _capacity)
{
reverse(_capacity == 0 ? 4 : _capacity * 2); //尾插之前先判断要不要扩容
}
_str[_size] = c;
++_size;
_str[_size] = '\0'; //注意处理最后一个字符的后面必须是'\0'
}
//复用insert函数
void push_back(const char c)
{
insert(_size,c);
}append函数
尾插一个字符串
//正常实现代码
void append(const char* str)
{
size_t n = _size + strlen(str);
_capacity = n;
char* tmp = new char[_capacity + 1];
strcpy(tmp, _str);
delete[] _str;
strcpy(tmp + _size, str);
_str = tmp;
_size = _capacity;
}
//复用insert函数
void append(const char* str)
{
insert(_size,str);
}
尾插一个string类型的对象
//复用insert函数
void append(const string& s)
{
insert(_size,s._str);
}
find函数
查找首次出现的字符所在的位置
size_t find(char c, size_t pos = 0) const
{
assert(pos < _size);
for (size_t i = pos; i < _size; i++)
{
if (_str[i] == c)
{
return i;
}
}
return -1;
}查找首次出现的字符串所在的位置
size_t find(const char* str, size_t pos = 0) const
{
const char* p = strstr(_str + pos, str);
if (p == nullptr)
{
return -1;
}
else
{
return p - _str;
}
}迭代器函数
string的迭代器本质上就是char*指针
typedef char* iterator;
iterator begin()
{
return _str;
}
iterator end()
{
return _str + _size;
}
//const对象迭代器函数
typedef const char* const_iterator;
const_iterator begin() const
{
return _str;
}
const_iterator end() const
{
return _str + _size;
}clear函数
意义是清空字符串，注意，这里不是清除空间！
void clear()
{
if (_size)
{
_size = 0;
_str[0] = '\0';
}
}swap函数
交换两个类的内容
void swap(string& s)
{
std::swap(_str, s._str);
std::swap(_size, s._size);
std::swap(_capacity, s._capacity);
}运算符重载
<<
这里的函数不需要私有成员变量，因此函数可以在类外声明定义
返回值是ostream& 方便实现连续的流插入
ostream& operator<<(ostream& _cout, const string& s)
{
for (auto ch : s)
{
_cout << ch;
}
return _cout;
}>>
这里的函数不需要私有成员变量，因此函数可以在类外声明定义
返回值是istream& 方便实现连续的流提取
istream& operator>>(istream& _cin, string& s)
{
char ch;
size_t i = 0;
ch = _cin.get();//get()函数保证可以取到' '和'\n'，能够结束循环，不能写成_cin >> ch!
char buff[128] = { '\0' };
while (ch != ' ' && ch != '\n')
{
buff[i++] = ch;
if (i == 127)//预留一个位置给'\0'
{
s += buff;
memset(buff, '\0', 128);
i = 0;
}
ch = _cin.get();
}
s += buff;
return _cin;
}开辟buff数组是为了进行优化，避免了多次开辟空间的操作，节省时间。
[ ]
char& operator[](size_t n)
{
assert(n < _size);
return _str[n];
}
//const变量的[]重载
const char& operator[](size_t index) const
{
assert(index < _size);
return _str[index];
}+=
1.尾插单个字符
string& operator+=(const char c)
{
push_back(c);//复用
return *this;
}2.尾插字符串
string& operator+=(const char* str)
{
append(str);//复用
return *this;
}3.尾插string类
string& operator+=(const string& s)
{
append(s);//复用
return *this;
}=
string& operator = (const string& s)
{
if (this != &s)
{
delete[] _str;//删除原有空间，防止内存泄漏
_size = _capacity = strlen(s._str);
char* tmp = new char[_capacity + 1];//重新开辟空间
_str = tmp;
strcpy(_str, s._str);
}
return *this;//支持连等
}<
bool operator<(const string& s)
{
return strcmp(_str, s._str) < 0;
}==
bool operator==(const string& s)
{
return strcmp(_str, s._str) == 0;
}<=
bool operator<=(const string& s)
{
return *this < s || *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);//复用
}小结
string类的模拟实际上就是对字符串的一系列操作，增删查改的功能，运算符的实现等等。今天的分享就到这里，我们下期见^_^
723
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
