【C++初阶】一篇手撕string类底层实现

string类各函数接口

namespace cl
{
   
   
	//模拟实现string类
	class string
	{
   
   
	public:
		typedef char* iterator;
		typedef const char* const_iterator;

		//默认成员函数
		string(const char* str = "");         //构造函数
		string(const string& s);              //拷贝构造函数
		string& operator=(const string& s);   //赋值运算符重载函数
		~string();                            //析构函数

		//迭代器相关函数
		iterator begin();
		iterator end();
		const_iterator begin()const;
		const_iterator end()const;

		//容量和大小相关函数
		size_t size();
		size_t capacity();
		void reserve(size_t n);
		void resize(size_t n, char ch = '\0');
		bool empty()const;

		//修改字符串相关函数
		void push_back(char ch);
		void append(const char* str);
		string& operator+=(char ch);
		string& operator+=(const char* str);
		string& insert(size_t pos, char ch);
		string& insert(size_t pos, const char* str);
		string& erase(size_t pos, size_t len);
		void clear();
		void swap(string& s);
		const char* c_str()const;

		//访问字符串相关函数
		char& operator[](size_t i);
		const char& operator[](size_t i)const;
		size_t find(char ch, size_t pos = 0)const;
		size_t find(const char* str, size_t pos = 0)const;

	private:
		char* _str;       //存储字符串
		size_t _size;     //记录字符串当前的有效长度
		size_t _capacity; //记录字符串当前的容量
		static const size_t npos; //静态成员变量（整型最大值）
	};
	const size_t string::npos = -1;

	//<<和>>运算符重载函数
	istream& operator>>(istream& in, string& s);
	ostream& operator<<(ostream& out, const string& s);
	istream& getline(istream& in, string& s);
}

注：为了防止与标准库当中的string类产生命名冲突，模拟实现时需放在自己的命名空间当中。

默认成员函数

构造函数

构造函数设置为缺省参数，若不传入参数，则默认构造为空字符串。字符串的初始大小和容量均设置为传入C字符串的长度（不包括’\0’）

//构造函数
string(const char* str = "")
{
   
   
	_size = strlen(str);
	_capacity = _size;
	_str = new char[_capacity + 1];//为存储字符串开辟空间（多开一个用于存放'\0'）

	strcpy(_str, str);
}

拷贝构造函数

在模拟实现拷贝构造函数前，我们应该首先了解深浅拷贝：

浅拷贝：拷贝出来的目标对象的指针和源对象的指针指向的内存空间是同一块空间。其中一个对象的改动会对另一个对象造成影响。
深拷贝：深拷贝是指源对象与拷贝对象互相独立。其中任何一个对象的改动不会对另外一个对象造成影响。

很明显，我们并不希望拷贝出来的两个对象之间存在相互影响，因此，我们这里需要用到深拷贝。下面提供深拷贝的两种写法：
写法一：传统写法

先开辟一块足以容纳源对象字符串的空间，然后将源对象的字符串拷贝过去，接着把源对象的其他成员变量也赋值过去即可。因为拷贝对象的_str与源对象的_str指向的并不是同一块空间，所以拷贝出来的对象与源对象是互相独立的。

//传统写法
string(const string& s)
{
   
   
	_str = new char[s._capacity + 1];
	strcpy(_str, s._str