轻松掌握string类常用接口(附模拟实现)（附图解）
目录:
--> String的常用接口说明(最常用的)
-> string类对象的容量操作
-> string类对象的访问及遍历操作
-> string类对象的修改操作
-> string类非成员函数
--> 深浅拷贝
--> 写时拷贝 Copy-On-Write
如果对C++的类还很陌生可以看看下面这些类和对象的博客
类和对象（上）https://blog.csdn.net/Obto_/article/details/127245441?spm=1001.2014.3001.5501
https://blog.csdn.net/Obto_/article/details/127245441?spm=1001.2014.3001.5501 类和对象（中）
https://blog.csdn.net/Obto_/article/details/127261735?spm=1001.2014.3001.5501
https://blog.csdn.net/Obto_/article/details/127303410?spm=1001.2014.3001.5501
前言：string是表示字符串的的字符串类，该类的接口和常规容器接口基本相同，string的底层实际是：basic_string模板类的别名,typedef basic_string
String的常用接口说明(最常用的)
| (constructor)函数名称 | 功能说明 |
|---|---|
| string() (重点) | 构造空的string类对象，即空字符串 |
| string(const char* s)(重点) | 用C-string(字符串)来构造string对象 |
| string(size_t n,char c) | string类对象中包含n个字符c |
| string(const string&s)(重点) | 拷贝构造函数 |
void Teststring()
{
string s1; // 构造空的string类对象s1
string s2("hello bit"); // 用C格式字符串构造string类对象s2
string s3(s2); // 拷贝构造s3
}下面是对常用接口的模拟：
namespace my_string
{
class string
{
public:
string(const char* str = "") //构造函数
{ //构造函数可以是缺省的
_size = strlen(str); //当没有传初始化值的时候默认初始化成空串
_capacity = _size;
_str = new char[_capacity + 1];
}
string(const string& s) //拷贝构造函数
:_str(new char[s._capacity + 1]) //是用一个string类去初始化宁一个string类
, _size(s._size)
, _capacity(s._capacity)
{
strcpy(_str, s._str); //C库中的复制s._str到_str中
}
private:
char* _str;//字符串
size_t _capacity;//容量
size_t _size;//大小
public:
const static int npos = -1;
};
}注意：上列的拷贝构造函数是古典式写法，下面提供一种现代式写法，也是老板式写法
这些都在上面的namespace my_string中 分开写为了强调代码
void swap(string &tmp)
{
::swap(_str, tmp._str);//这里使用::是使用c++库中的swap函数
::swap(_size, tmp._size);
::swap(_capacity, tmp._capacity);
}
string(const string& s)//要把string类s 给 _str 所以要清除_str
{
:_str(nullptr)
,_size(0)
,_capacity(0)
{
tring tmp(s._str);
swap(tmp);
}
}
/操作解析：首先要知道我们模拟的string类中有一个保存字符串的私有成员：_str 这时候要给_str赋值可以先建立一个打工人tmp 用 传过来的string类s来调用构造函数来构造tmp，再交换tmp和_str的各项的数值 与 下列代码一个意思
void m_swap(int a,int b)
{
int tmp = a;
a=b;
b=a;
}注意 ：如果String类没有显式定义其拷贝构造函数与赋值运算符重载，此时编译器会生成默认的，当用s1构造s2时，编译器会调用默认的拷贝构造。最终导致的问题是，s1、s2共用同一块内存空间，在释放时同一块空间被释放多次而引起程序崩溃，这种拷贝方式，称为浅拷贝。
string类对象的容量操作
| 函数名称 | 功能说明 |
|---|---|
| size(重点) | 返回字符串有效长度 |
| length | 返回字符串有效长度 |
| capacity | 返回总空间大小 |
| empty(重点) | 检测字符串是否为空串，是返回true否则返回flase |
| clear(重点) | 清除有效字符 |
| reserve(重点) | 为字符串预留空间 |
| resize(重点) | 将有效字符个数改成n个，多出的空间用字符c填充 |
发
namespace my_string
{
class string
{
size_t size()const //由于length跟size一个性质 就实现size
{
return _size;
}
size_t capacity()const //返回my_string类中私有成员_capacity
{
return _capacity;
}
bool empty()const
{
return _size == 0; //如果_size为0代表有效字符为0 字符串为空
}
void clear()
{
_str[0] = '\0'; //清除my_string中的有效字符，但容量不变
_size = 0;
}
void reserve(size_t n) //给函数扩容n个
{
if (_capacity < n) //如果输入的n小于_capacity就不扩容
{
char* tmp = new char[n + 1];//有效字符为n开n+1是为了给'\0'留个位置
_size = n;
_capacity = n;
strcpy(tmp, _str);
delete[] _str;
_str = tmp;
}
}
void resize(size_t n, char c = '\0')//调整容器的有效数量 hello
{
if (n <= _capacity)//截取 小于等于 容量
{
_str[n] = '\0';
}
else {
reserve(n); //扩容
_capacity = n;
for (int i = _size; i < n; i++)//填充
{
push_back(c);//尾插
}
}
}
private:
char* _str;//字符串
size_t _capacity;//容量
size_t _size;//大小
public:
const static int npos = -1;
};
}注意：
1 ) size()与length()方法底层实现原理完全相同，引入size()的原因是为了与其他容器的接口保持一致，一般情况下基本都是用size()。
2 ) clear()只是将string中有效字符清空，不改变底层空间大小
3 ) resize(size_t n) 与 resize(size_t n, char c)都是将字符串中有效字符个数改变到n个，不同的是当字符个数增多时：resize(n)用0来填充多出的元素空间，resize(size_t n, char c)用字符c来填充多出的元素空间。注意：resize在改变元素个数时，如果是将元素个数增多，可能会改变底层容量的大小，如果是将元素个数减少，底层空间总大小不变
4 ) 当reserve的参数小于string的底层空间总大小时，reserver不会改变容量大小
string类对象的访问及遍历操作
| 函数名称 | 功能说明 |
|---|---|
| operator[ ](重点 ) | 返回pos的位置的字符，const string类对象调用 |
| begin+end | begin获取一个字符迭代器+end获取最后一个字符下一个位置的迭代器 |
| rbegin+rend | begin获取一个字符迭代器+end获取最后一个字符下一个位置的迭代器 |
| 范围for | C++11支持更简洁的范围for新遍历方式 |
namespace my_string
{
class string
{
public:
char& operator[](size_t index) //重载[]
{
assert(index < _size);
return _str[index];
}
const char& operator[](size_t index)const
{
assert(index < _size);
return _str[index];
}
typedef char* iterator; //iterator就是char* 类型的指针
typedef const char* const_iterator; //const_iterator就是 const char* 类型的指针
const_iterator begin() const
{
return _str;
}
const_iterator end() const
{
return _str + _size;
}
iterator begin()
{
return _str;
}
iterator end()
{
return _str + _size;
}
private:
char* _str;//字符串
size_t _capacity;//容量
size_t _size;//大小
public:
const static int npos = -1;
};
}string类对象的修改操作
| 函数名称 | 功能说明 |
|---|---|
| push_back | 在字符串后尾插字符c |
| append | 在字符串后追加一个字符串 |
| operator+=（重点） | 在字符串后追加字符串str |
| c_str（重点） | 返回C格式字符串 |
| find+npos（重点） | 从字符串pos位置开始找字符c，返回该字符的位置 |
| rind | 从字符串pos位置开始找字符c，返回该字符的位置 |
| substr | 在str中从pos位置开始，截取n个字符，然后将其返回 |
namespace my_string
{
class string
{
public:
void push_back(char c)
{
if (_size == _capacity) //日常检测空间满了没有
{
reserve(_capacity == 0 ? 4 : 2 * _capacity);//调用reserve开空间
}
_str[_size] = c;
_size++;
_str[_size] = '\0';
}
void append(const char* str) //追加字符串
{
int len = strlen(str);
if (len + _size > _capacity)//老规矩检查容量
{
reserve(len + _size);
}
strcpy(_str+_size, str);
_size += len;
}
string& operator+=(const char* str)
{
append(str); //直接复用
return *this; //返回是为了可以连续+= a+=b+=c
}
const char* c_str()const
{
return _str; //返回字符串(返回的是char*)
}
size_t find(char c, size_t pos = 0) const //返回的是第一次找到字符c的位置
{
for (int i = 0; i < _size; i++)
{
if (_str[i] == 'c')
return i;
}
return npos; //没找到返回npos值为-1
}
size_t find(const char* s, size_t pos = 0) const //返回字符串第一次出现的位置
{
const char* ptr = strstr(_str + pos, s); //c库中找子串的函数
if (ptr == nullptr)
{
return npos;
}
else {
return ptr - _str; //指针相减得出位置
}
}
private:
char* _str;//字符串
size_t _capacity;//容量
size_t _size;//大小
public:
const static int npos = -1;
};
}注意：
- 在string尾部追加字符时，s.push_back(c) / s.append(1, c) / s += 'c'三种的实现方式差不多，一般情况下string类的+=操作用的比较多，+=操作不仅可以连接单个字符，还可以连接字符串。
- 对string操作时，如果能够大概预估到放多少字符，可以先通过reserve把空间预留好。
string类非成员函数
| 函数 | 功能说明 |
|---|---|
| operator+ | 尽量少用，传值返回，导致深拷贝效率低 |
| operator>>（重点） | 输入运算符重载 |
| operator<<（重点） | 输出运算符重载 |
| relation operators（重点） | 大小比较 |
namespace my_string
{
class string
{
public:
string& operator+(const char* str)
{
string tmp(*this);
tmp += str;
return tmp;
}
friend ostream& operator<<(ostream& _cout, const my_string::string& s);
friend istream& operator>>(istream& _cin, gch::string& s);
bool operator<(const string& s)
{
return strcmp(_str, s._str) < 0;
}
bool operator<=(const string& s)
{
return !(_str > s._str);
}
bool operator>(const string& s)
{
return strcmp(_str, s._str) > 0;
}
bool operator>=(const string& s)
{
return !(_str < s._str);
}
bool operator==(const string& s)
{
return strcmp(_str, s._str) == 0;
}
bool operator!=(const string& s)
{
return !(_str == s._str);
}
private:
char* _str;//字符串
size_t _capacity;//容量
size_t _size;//大小
public:
const static int npos = -1;
};
}
ostream& operator<<(ostream& _cout, const my_string::string& s)
{
for (size_t i = 0; i < s.size(); i++)
{
_cout << s[i]; //_cout就是输出流里cout的别名 下面cin同理
}
return _cout;
}
istream& operator>>(istream& _cin, my_string::string& s)
{
for (size_t i = 0; i < s.size(); i++)
{
_cin >> s[i];
}
return _cin;
}模拟到此结束 下面为string类的进一步探索 ！！！
深浅拷贝
浅拷贝 ：也称位拷贝，编译器只是将对象中的值拷贝过来。如果对象中管理资源，最后就会导致多个对象共享同一份资源，当一个对象销毁时就会将该资源释放掉，而此时另一些对象不知道该资源已经被释放，以为还有效，所以当继续对资源进项操作时，就会发生发生了访问违规
图中为浅拷贝，s1和s2指向同一块空间
深拷贝：如果一个类中涉及到资源的管理，其拷贝构造函数、赋值运算符重载以及析构函数必须要显式给出。一般情况都是按照深拷贝方式提供
图中为深拷贝s1与s2分别指向不同的的空间。
写时拷贝 Copy-On-Write
Q1:Copy-On-Write的原理是什么？
A1: Copy-On-Write一定使用了“引用计数”当第一个类构造时，string的构造函数会根据传入的参数从堆上分配内存，当有其它类需要这块内存时，这个计数为自动累加，当有类析构时，这个计数会减一，直到最后一个类析构时，此时的RefCnt为1或是0，此时，程序才会真正的Free这块从堆上分配的内存。
Q2:string类是在什么时候共享内存的呢？
A2：如果一个类要用另一个类的数据，那就可以共享被使用类的内存了。无非有两种情况
1）用别的类构造自己 ，2）以别的类进行赋值。第一种情况会触发拷贝构造，第二种情况会触发赋值操作符。对于第一种情况，只需要在string类的拷贝构造函数中做点处理，让其引用计数累加；同样，对于第二种情况，只需要重载string类的赋值操作符，同样在其中加上一点处理。
Q3：string类在什么情况下才触发写时拷贝
A3：很显然，当然是在共享同一块内存的类发生内容改变时，才会发生Copy-On-Write，比如string类的 [] 、= 、+= 、 + 、操作符赋值，还有一些成员函数insert,replace,append也包括类的析构。如果不修改数据就不会触发Copy-On-Write。这就是拖延战术的真谛，非到万不得已才去做
Q4：Copy-On-Write具体是怎样实现的
A4：我们要让h1,h2,h3共享一块内存.w1,w2共享一块内存。因此在h1,h2,h3中我们要维护一个引用计数，在w1,w2中也要维护一个引用计数。由于string类是在堆上动态开辟的一块空间，那么我们为什么不在这块去上多分配一点来存放引用计数呢？这样共享的同一个内存区的类都有一个引用计数，也就知道这块内存有多少人使用了
string h1 = “hello”;
string h2= h1;
string h3;
h3 = h2;
string w1 = “world”;
string w2(“”);
w2=w1;
提上一嘴，很多string类的实现都采用了Copy-On-Write，虽然这是一个很有效率的技术，但是因为内存的共享导致程序在“多线程”环境中容易出现错误如果分别在两个线程中的 string 实例共享着同一块内存，很有可能发生潜在的内存问题 。