前言

因为学习了string的相关知识，了解了string大部分接口的底层实现原理，所以我决定自己模拟实现一个mini版的string类，用来加深对string各方面知识的理解。
如果有错误或不足之处，还望各位读者小伙伴们指出。

一、包含的相关头文件

#include<iostream>
#include<assert.h>
#include<cstring>
using std::ostream;
using std::istream;
using std:: cout;
using std:: endl;

二、构造和析构

1.构造函数

		//构造
		string(const char* str = "")
		{
			size_t len = strlen(str);
			_capacity = _size = len;
			_str = new char[_capacity + 1];
			strcpy(_str, str);
		}

2.拷贝构造

1.传统写法

该对象自己一点一点的进行深拷贝

		//拷贝构造
		string(const string& s)
		{
			_str = new char[s._capacity + 1];
			_size = s._size;
			_capacity = s._capacity;
			strcpy(_str, s._str);
		}

2.现代写法

找一个中间对象，让这个中间对象用参数的值进行直接构造，再将这个中间对象的内容与自己的内容进行交换。相较于传统写法，现代写法更加简洁。

		//拷贝构造
		string(const string& s)
			:_str(nullptr),//此处要注意将该对象的地址赋值为nullptr，否则析构中间对象时会因为发生野指针的访问而导致程序崩溃。
			_size(0),
			_capacity(0)
		{
			string temp(s);
			swap(temp);
		}

此处的swap用的是string自己实现的swap，为什么不用库里的swap呢？因为库里的swap是进行深拷贝，会降低效率。我们自己实现的swap只需要进行浅拷贝，即将它们对应的资源进行交换即可。

		void swap(string& s)
		{
			std::swap(_str, s._str);
			std::swap(_size, s._size);
			std::swap(_capacity, s._capacity);
		}

3.赋值运算符重载

1.传统写法

		//赋值运算符重载
		string& operator=(const string &s)
		{
			if (this != &s)
			{
				char* temp = new char[s._capacity + 1];//用一个中间值记录新开辟的空间，如果开辟空间成功，再将该空间的地址给_str。避免因为开辟空间失败，_str原本的内容也销毁的情况发生。
				strcpy(temp, s._str);
				delete[] _str;
				_str = temp;
				_capacity = s._capacity;
				_size = s._size;
			}
			return *this;
		}

2.现代写法

与拷贝构造的现代写法思想类似，可以使程序更加简洁。并且此处不需要专门定义一个中间对象，因为传值传参传过来的形参是实参拷贝构造出来的对象，它就是一个很好的中间对象，我们直接和它进行交换即可。

		//赋值运算符重载
		string& operator=(string s)
		{
			swap(s);
			return *this;
		}

4.析构函数

		//析构
		~string()
		{
			delete[] _str;
			_str = nullptr;//释放指针所指向的空间后要将该指针置为空（避免出现野指针的非法访问）
			_size = _capacity = 0;
		}

三、iterator

迭代器是一个使用起来像指针的东西，实际上string的迭代器就是char*类型的指针，因此我们先在最开始进行typedef

typedef char* iterator;

定义两个迭代器：分别指向字符串开头和结尾

		iterator begin()
		{
			return _str;
		}
		iterator end()
		{
			return _str + _size;
		}

四、modify

1.push_back(尾插一个字符）

string只提供了push_back的接口没有提供头插的接口，因为头插需要移动数据，效率很低，所以尽量不要在string中使用头插。

		void push_back(char c)
		{
			if (_size == _capacity)
			{
				size_t newcapacity = _capacity == 0 ? 4 : _capacity * 2;//要考虑到如果初始字符串的容量为0的情况
				reserve(newcapacity);
				_capacity = newcapacity;
			}
			_str[_size++] = c;
			_str[_size] = '\0';
		}

2.append（尾插一个字符串）

		void append(const char* str)
		{
			size_t len = strlen(str);
			if (len + _size > _capacity)
			{
				reserve(len + _size);
			}
			strcpy(end(), str);
			_size += len;
		}

3.运算符重载+=

1.尾插字符

尾插一个字符（复用尾插）

		string& operator+=(char c)
		{
			push_back(c);
			return *this;
		}

2.尾插字符串

尾插一个字符串（复用append）

		string& operator+=(const char* str)
		{
			append(str);
			return *this;
		}

4.clear

清除string中所有元素

		void clear()
		{
			_size = 0;
			_str[0] = '\0';
		}

5.insert

1.插入一个字符

在字符串某位置插入一个字符：

		// 在pos位置上插入字符c/字符串str
		string& insert(size_t pos, char c)
		{
			assert(pos <= _size);
			if (_size + 1 > _capacity)
			{
				reserve(_size + 1);
			}
			for (size_t i = _size + 1; i > pos; --i)//要注意避免i减为-1变成一个极大的无符号数，导致死循环
			{
				_str[i] = _str[i - 1];
			}
			_str[pos] = c;
			++_size;
			return *this;
		}

2.插入一个字符串

在字符串某位置插入一个字符串：

		string& insert(size_t pos, const char* str)
		{
			assert(pos <= _size);
			size_t i = 0;
			size_t len = strlen(str);
			if (_size + len > _capacity)
			{
				reserve(_size + len);
			}
			for (i = _size + len; i > pos + len - 1; --i)
			{
				_str[i] = _str[i - len];
			}
			strncpy(_str + pos, str, len);
			_size += len;
			return *this;
		}

6.erase

删除从字符串某位置开始，某长度的子串（如果不说明删除子串的长度，则默认从开始位置到最后的所有内容都删除）

		// 删除pos位置上的元素
		string& erase(size_t pos, size_t len = npos)
		{
			if (len == npos || pos + len > _size)
			{
				_str[pos] = '\0';
				_size = pos;
			}
			else
			{
				strcpy(_str + pos, _str + pos + len);
				_size -= len;
			}
			return *this;
		}

五、capacity

1.size

类外成员不能直接访问类的私有属性/数据，因此需要提供一个接口进行访问数据，但是要对数据进行保护，因此用了const传参和传值返回。
访问string中的元素个数。

		size_t size()const
		{
			return _size;
		}

2.capacity

访问string的容量。

		size_t capacity()const
		{
			return _capacity;
		}

3.empty

判断字符串是否为空。

		bool empty()const
		{
			if (_size == 0)
			{
				return true;
			}
			return false;
		}

4.resize

修改字符串的元素个数，可以尾插指定的字符，未指定则默认插入’\0’。

		void resize(size_t n, char c = '\0')//更改元素个数
		{
			if (n <= _size)
			{
				_size = n;
				_str[_size] = '\0';
			}
			else
			{
				reserve(n);//先扩容，再加元素
				for (size_t i = _size; i < n; ++i)
				{
					_str[i] = c;
				}
				_str[n] = '\0';
				_size = n;
			}
		}

5.reserve

修改字符串的容量。

		void reserve(size_t n)//更改容量大小
		{
			if (n > _capacity)
			{
				char* temp = new char[n + 1];//先开空间再拷贝值（避免因为空间开辟失败的异常使_str原地址也丢失了）
				strcpy(temp, _str);
				delete[] _str;
				_str = temp;
				_capacity = n;
			}
		}

六、access

访问字符串中的字符，运算符[]重载。

1.普通对象的接口（可读可写）

		char& operator[](size_t index)//普通对象的接口（可读可写）
		{
			assert(index < _size);
			return _str[index];
		}

2.const对象的接口（只读）

		const char& operator[](size_t index)const//const对象的接口（只读）
		{
			assert(index < _size);
			return _str[index];
		}

七、relational operators

1.运算符<重载

		bool operator<(const string& s)
		{
			size_t len = _size < s._size ? _size : s._size;
			for (size_t i = 0; i < len; ++i)
			{
				if ((*this)[i] >= s[i])
				{
					return false;
				}
				return true;
			}
		}

2.运算符>重载

		bool operator>(const string& s)
		{
			size_t len = _size < s._size ? _size : s._size;
			for (size_t i = 0; i < len; ++i)
			{
				if ((*this)[i] <= s[i])
				{
					return false;
				}
				return true;
			}
		}

3.运算符<=重载

复用>。

		bool operator<=(const string& s)
		{
			return !(*this > s);
		}

4.运算符>=重载

复用<。

		bool operator>=(const string& s)
		{
			return !(*this < s);
		}

5.运算符==重载

复用<和>。

		bool operator==(const string& s)
		{
			return (!((*this) < s)) && (!((*this) > s));
		}

6.运算符!=重载

复用==。

		bool operator!=(const string& s)
		{
			return !((*this) == s);
		}

八、String operations

1.find

1.找字符

找一个字符第一次在字符串中出现的下标

		// 返回c在string中第一次出现的位置(下标)
		size_t find(char c, size_t pos = 0) const
		{
			assert(pos < _size);
			for (size_t i = 0; i < _size; ++i)
			{
				if ((*this)[i] == c)
				{
					return i;
				}
			}
			return npos;
		}

2.找子串

找一个子串第一次出现在字符串中的下标
复用C语言对字符串的操作——strstr函数（在一个字符串中找子串）

		// 返回子串s在string中第一次出现的位置(下标)
		size_t find(const char* s, size_t pos = 0) const
		{
			assert(pos < _size);
			const char* ptr = strstr(_str + pos, s);
			if (ptr == nullptr)
			{
				return npos;
			}
			else
			{
				return ptr - _str;
			}
		}

也可以一个字符一个字符的遍历寻找：

		// 返回子串s在string中第一次出现的位置(下标)
		size_t find(const char* s, size_t pos = 0) const
		{
			assert(pos < _size);
			size_t i = 0;
			while (i < _size)
			{
				int flag = 0;
				if ((*this)[i] == s[0])
				{
					size_t k = i;
					for (size_t j = 0; j < strlen(s); ++j, ++k)
					{
						if ((*this)[k] != s[j])
						{
							flag = 1;
						}
					}
					if (flag == 0) return i;
				}
				i++;
			}
			return npos;
		}

2.c_str

返回字符串的地址

		const char* c_str()const
		{
			return _str;
		}

九、Non-member function overloads

1.流插入

	ostream& operator<<(ostream& _cout, const string& s)
	{
		for (size_t i = 0; i < s.size(); i++)
		{
			_cout << s[i];
		}
		return _cout;
	}

2.流提取

	istream& operator>>(istream& _cin, string& s)
	{
		s.clear();//将原来s中的值清除
		char buff[128] = { '\0' };
		size_t i = 0;
		char ch = _cin.get();//这里不能使用getc或者scanf函数的原因是他们都是按照空格' '或者换行'\n'进行分割内容的，所以无法取到空格和换行，因此只能用get()
		while (ch != ' ' || ch != '\n')
		{
			if (i == 127)//缓存部分满了
			{
				s += buff;//将内容存入s，同时将缓存部分情况
				i = 0;
			}
			buff[i++] = ch;
			ch = _cin.get();
		}
		return _cin;
	}

十、私有属性

	private:
		char* _str;
		size_t _capacity;
		size_t _size;
		const static size_t npos = -1;//只有这个特例可以这样定义，其他static数据成员都要在类内声明，在类外定义。

总结

以上就是今天要讲的内容，本文介绍了作者自己实现的string类的相关类成员函数，如果文章中的内容有错误或者不严谨的部分，欢迎大家在评论区指出，也欢迎大家在评论区提问、交流。
最后，如果本篇文章对你有所启发的话，希望可以多多支持作者，谢谢大家！