-
string是一个管理字符数组的类，要求这个字符数组结尾用\0标识 -
模拟实现涉及的问题如下：
- 拷贝构造和赋值重载实现 深拷贝
- 增删查改的相关接口
- 重载一些常见的运算符如：
[]、>>、<<等 - 迭代器
-
对于一个成员函数，什么时候该加
const呢？- 如果是 只读函数 ，则要加
const - 如果是 只写函数 ，则不能加
const - 如果 既是可读又是可写的函数 ，则要重载两个版本的函数，即
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;
}
/////////////////////////////////////////////////////////////
// capacity
size_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'); // 设置有效字符个数
/////////////////////////////////////////////////////////////
// access
char& operator[](size_t index)// at左右与[]类似，但是at越界是抛异常
{
assert(index < _size); // 这里无需判断>=0的情况，因为index的类型是size_t
return _str[index];
}
// 要写两个版本，因为如果是const对象调用operator[]的话，若没有两个版本则只能读不能写
const char& operator[](size_t index) const
{
assert(index < _size);
return _str[index];
}
//////////////////////////////////////////////////////////////
// modify
void 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 函数
-
n如果 小于_size的话，直接将size减少到n即可。 -
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的库函数strstr
const 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，则仍然要进行深拷贝操作