Ⅰ. string类的介绍以及一些常见问题

string的文档网站

• string 是一个管理字符数组的类，要求这个字符数组结尾用 \0 标识

• 模拟实现涉及的问题如下：

  • 拷贝构造和赋值重载实现 深拷贝
  • 增删查改的相关接口
  • 重载一些常见的运算符如：[] 、>> 、<< 等
  • 迭代器

• 对于一个成员函数，什么时候该加 const 呢？

  1. 如果是 只读函数 ，则要加 const
  2. 如果是 只写函数 ，则不能加 const
  3. 如果 既是可读又是可写的函数 ，则要重载两个版本的函数，即 const 版本与 非const 版本

Ⅱ. string类的模拟实现

类的整体框架（简单的直接在框架实现了）

#include <iostream>
#include <cstring> // 运用C++风格的头文件
#include <cassert>
using namespace std;namespace liren // 为了防止与库里的string的冲突，使用自己的命名空间
{class string{public: typedef char* iterator;   // 用于普通对象的迭代器typedef const char* const_iterator;   // 用于const对象的迭代器public:string(const char* str = ""); // 构造函数,且缺省值必须给""，而不是nullptr或者"\0"~string(); // 析构函数string(const string& s); // 现代写法的拷贝构造函数(深拷贝问题)string& operator=(const string& s); // 现代写法的赋值运算符重载(深拷贝问题)void swap(string& s); // 自己写的swap去调用全局swap完成类成员变量的交换//// iterator 与 const_iterator 迭代器  iterator begin() // 用于普通对象，可读可写{return _str;}const_iterator begin() const // 用于const对象，只能读{return _str;}iterator end(){return _str + _size;}const_iterator end() const{return _str + _size;}/// capacitysize_t size() const{return _size;}size_t capacity() const{return _capacity;}bool empty() const{return _size == 0;}void reserve(size_t n); // 预留空间（用于防止多次增容，提高效率）void resize(size_t n, char c = '\0'); // 设置有效字符个数/// accesschar& operator[](size_t index)// at左右与[]类似，但是at越界是抛异常{assert(index < _size); // 这里无需判断>=0的情况，因为index的类型是size_treturn _str[index];}// 要写两个版本，因为如果是const对象调用operator[]的话，若没有两个版本则只能读不能写const char& operator[](size_t index) const {assert(index < _size);return _str[index];}//// modifyvoid push_back(char c); void append(const char* str); // 追加一个字符串string& operator+=(char c) // 两个+=的重载函数可以调用上面的push_back以及append进行复用{push_back(c);return _str;}string& operator+=(const char* str){append(str);return _str;}void clear(){_size = 0;_str[_size] = '\0';}const char* c_str() const // 因为该函数只读，所以用const修饰{return _str;}/// 返回字符c在string中第一次出现的位置size_t find(char c, size_t pos = 0) const;// 返回子串s在string中第一次出现的位置size_t find(const char* str, size_t pos = 0) const;// 在pos位置上插入字符c/字符串str，并返回该字符的位置string& insert(size_t pos, char c);string& insert(size_t pos, const char* str);// 删除pos位置上的元素，并返回该元素的下一个位置string& erase(size_t pos, size_t len = npos);private:char* _str; 	  // 管理字符数组的指针size_t _capacity; // 数组的容量(不包括'\0')size_t _size; 	  // 有效字符个数static const size_t npos; // 类外定义};/// 表示关系的运算符重载（作为非成员函数重载）// 以及输入输出的运算符重载ostream& operator<<(ostream& out, const string& s);istream& operator>>(istream& in, const string& s);bool operator<(const string& s1, const string& s2){return strcmp(s1.c_str(), s2.c_str()) < 0;}bool operator<=(const string& s1, const string& s2){return strcmp(s1.c_str(), s2.c_str()) <= 0;}bool operator>(const string& s1, const string& s2){return strcmp(s1.c_str(), s2.c_str()) > 0;}bool operator>=(const string& s1, const string& s2){return strcmp(s1.c_str(), s2.c_str()) >= 0;}bool operator==(const string& s1, const string& s2){return strcmp(s1.c_str(), s2.c_str()) == 0;}bool operator!=(const string& s1, const string& s2){return strcmp(s1.c_str(), s2.c_str()) != 0;}const size_t string::npo = -1;
}

构造函数与析构函数（重点）

string(const char* str = "")	// 构造函数,且缺省值必须给""，而不是nullptr或者"\0"
{assert(str != nullptr);// 开辟字符数组空间，然后对类内参数进行初始化_size = strlen(str);_capacity = _size;_str = new char[_capacity + 1]; // 这里要多留一个空间给'\0'strcpy(_str, str);
} ~string()
{// 析构字符数组空间delete[] _str;_str = nullptr;_size = _capacity = 0;
}

现代写法的拷贝构造以及赋值运算符重载（重点）

// 拷贝构造函数
string(const string& s) : _str(nullptr)  // 这里将_str置为nullptr是为了在下面调用swap(tmp)时候最后析构tmp不会将随机值处的数据析构掉，而是析构nullptr, _size(0) , _capacity(0)
{string tmp(s._str); // 这里调用的是构造函数，而不是拷贝构造，如果调用拷贝构造，会死循环this->swap(tmp); 	// 具体看下面swap的实现，其实就是将成员函数交换了 
}// 赋值运算符重载函数
string& operator=(string s)  // 与拷贝构造不一样，这里使用传值
{this->swap(s);return *this;
}// 更严谨版本的赋值运算符重载（防止了自己给自己赋值，但是没必要这么写,因为基本没有自己给自己赋值的情况）
string& operator=(const string& s)
{if(*this != s){string tmp(s);this->swap(tmp);return *this;}
}

注意事项：

• 拷贝构造是在对象定义时候操作的，所以这个时候不会去调用构造函数，所以此时 this 的 _str 指向的地址是随机的，而与 tmp 交换成员变量的数据之后，tmp 就指向了随机处，出了该作用域就析构了，就会将随机值处的数据析构掉，导致内存数据的丢失。为了避免这种情况，在拷贝构造的时候增加初始化列表对 this 的成员变量进行初始化，将 _str 置为 nullptr。
• 赋值运算符重载 是在 对象存在之后 进行的赋值，所以无需将 this 处的 _str 置为 nullptr 以及初始化成员变量。

​ 此处又涉及一个概念，我们平常习惯于写成以下这种形式：

string s1 = "lirendada";

以 vs 编译器为例，上述代码其实是 隐式类型转换 :

• 编译器先将 lirendada 拿去调用 构造函数，再将这个 临时对象 赋给 s1，但现在的编译器做了优化，会直接将上述代码转化为调用 拷贝构造函数。
• 除此之外，可以用 explicit 关键字让编译器禁止这种隐式类型转换

swap 函数

void swap(string& s)  // 调用std库中的swap进行交换
{::swap(_str, s._str);::swap(_size, s._size);::swap(_capacity, s._capacity);
}

reserve 函数

void reserve(size_t n)  // 为数组预留空间，若 n 小于 _capacity 则无需操作
{if(n > _capacity){char* tmp = new char[n + 1]; // 多留一个位置给 \0// 注意，这里要把 _size+1 个空间一起拷过去，不然最后一个位置的 \0 没有被传过去的话，字符串就没有了尾，就会有随机值strncpy(tmp, _str, _size + 1); delete[] _str;_str = tmp;_capacity = n;}
}

resize 函数

1. n 如果 小于 _size 的话，直接将 size 减少到 n 即可。

2. n 如果 大于 _size 的话，要判断一下 n 是否大于 _capacity

   • 大于的话就得 扩容 ，并且填充指定字符
   • 不大于的话，则 直接填充指定字符 即可。

void resize(size_t n, char c = '\0'); // 设置有效字符个数
{if(n > _size){if(n > _capacity) // 大于容量则要扩容reserve(n);memset(_str + _size, c, n - _size); // 填充字符c_str[n] = '\0'; // 这步很关键，因为填充完后要将多留出的一位要置为'\0'_size = n;}else{_size = n;_str[_size] = '\0'; // 记得最后一位置为'\0'}
}

insert 函数

​ 该函数的作用：在 pos 位置上插入 字符c 或者 字符串str ，并返回该字符的位置！

// 插入一个字符c
string& insert(size_t pos, char c)
{assert(pos <= _size);if(_size == _capacity)reserve(_capacity == 0 ? 4 : _capacity * 2); // 这样子写防止容量为0的时候size_t end = _size;  // 从后往前挪动数据while(end > pos){_str[end] = _str[end - 1];--end;}_str[end] = c;_size++;_str[_size] = '\0'; // 记得_size处置为'\0'return *this;
}// 插入一个字符串str
string& insert(size_t pos, const char* str)
{assert(pos <= _size);int ls = strlen(str);int len = _size + ls; // 加起来的总长度if(len > _capacity)reserve(len);// 用指针挪动不容易出问题（顺便将'\0'也挪动了）char* end = _str + _size;while(end >= _str + pos){*(end + ls) = *end;end--;}strncpy(_str + pos, str, ls); // 将str拷过去_str的pos处，长度为ls_size = len;return *this;
}

push_back 函数

// 第一种方法，自己实现
void push_back(char c)
{if(_size == _capacity)reserve(_capacity == 0 ? 4 : 2 * _capacity); // 这样子写防止容量为0的时候_str[_size] = c;_size++;_str[_size] = '\0'; // 记得最后一位置为'\0'
}// 第二种方法，调用insert函数
void push_back(char c)
{this->insert(_size, c);
}

append 函数

// 第一种方法，自己实现
void append(const char* str)
{size_t len = _size + strlen(str);if (len > _capacity){reserve(len);}strcpy(_str + _size, str);_size = len;
}// 第二种方法，调用insert函数
void append(const char* str)
{this->insert(_size, str);   
}

erase 函数

string& erase(size_t pos, size_t len = npos) // 默认删除整个字符串
{assert(pos < _size);size_t leftLen = _size - pos;if(leftLen <= len) // 剩余的字符小于要删的长度{_str[pos] = '\0';_size = pos;}else{strpy(_str + pos, _str + pos + len);_size = len;}return *this;
}

find 函数

// 返回字符c在string中第一次出现的位置
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 npos;
}// 返回子串s在string中第一次出现的位置
size_t find(const char* str, size_t pos = 0) const
{assert(pos < _size);// 运用c的库函数strstrconst char* tmp = strstr(_str + pos, s);if (tmp == nullptr)return npos;// 两个指针相减求出该处的下标return tmp - _str;
}

>> 与 << 运算符重载（作为非成员函数重载）

ostream& operator<<(ostream& out, const string& s)
{//out << s._str << endl;  不能直接这样子，因为out遇到空格也会中断for (auto i : s)out << i;return out;
}istream& operator>>(istream& in, string& s)//注意s不能用const修饰
{//in >> s._str;  不能这样子写，因为遇到空格就中断了输入//char ch;//in >> ch;  //因为in是istream的对象，所以它遇见空格和换行也会中断s.clear();//记得先清理一下char ch = in.get();//get是istream库里的函数，接收的字符串不会因为空格而中断while (ch != ' ' && ch != '\n'){s += ch;ch = in.get();}return in;
}

getline 函数

istream& getline(istream& in, string& s)
{// 与 >> 的重载差不多，只不过遇到' ' 也就是空格也要接收s.clear();char ch = in.get();while (ch != '\n'){s += ch;ch = in.get();}return in;
}

Ⅲ. 写时拷贝

​ 写时拷贝就是一种拖延症，是在浅拷贝的基础之上增加了【引用计数】的方式来实现的。

​ 引用计数：用来记录资源使用者的个数。在构造时，将资源的计数 1，每增加一个对象使用该资源，就给计数加 1，当某个对象被销毁时，先给该计数减 1，然后再检查是否需要释放资源，如果计数为 1，说明该对象时资源的最后一个使用者，将该资源释放；否则就不能释放，因为还有其他对象在使用该资源。

​ 写时拷贝分为两个部分：

​ 1、运用引用计数的浅拷贝

​ 2、深拷贝

​ 优点：若只是读的时候，当拿一个对象去拷贝另一个对象时候，就给计数器加一，以此类推。。。在析构的时候，就只将计数器减一，直到计数器为 0 时才将这块空间释放，防止了多次析构，也减少了深拷贝，提高了效率。

​ 缺点：若要对这几个对象里的一个或多个对象进行写的操作，且计数器不为 1，则 仍然要进行深拷贝操作

写时拷贝

写时拷贝在读取是的缺陷

Ⅳ. 拓展阅读

面试中string的一种正确写法

STL中的string类怎么了？