（保姆级教学篇）C++中String的底层模拟实现

1.前言

           hello大家好，又很久没有更新了，由于沉迷于C++而无法自拔，导致很久没写了哈哈哈。这次给大家带来的就是我们C++里面的string类的模拟实现，尽管可以直接用，但是呢这也算一个数据结构，我们了解了它的底层会帮助我们更加理解string，会更让我们容易上手，尽管我们觉得string不是很简单嘛？但还是有很多细节的，我这的是完完全全按照库里的实现的，所以有需要的同学要好好的注意我的注释哦！

2.代码实现

        注释和代码我都放在下面了，十分详细哦！本次我们分为两个文件，一个.h一个.cpp，方便我们实现，请同学们细品细品~~

//String.h
#pragma once
#include<iostream>
#include<assert.h>

namespace bit
{
	class string
	{
	public:
		//迭代器
		typedef char* iterator;
		iterator begin();
		iterator end();
		// string的无参构造
		string();
		// 构造
		string(const char* str);  //这里也可以与上方的无参构造合并，给缺省参数： string(const char* str = ""); 
		// 深拷贝
		string(const string& s);
		// 赋值
		string& operator=(const string& s);
		// 析构
		~string();
		// c_str()
		const char* c_str() const;
		// size()
		size_t size() const;
		// []
		char& operator[](size_t pos);
		// reserve()
		void reserve(size_t n);
		// push_back()
		void push_back(char ch);
		// append()
		void append(const char* str);
		// +=
		string& operator+=(char ch);
		string& operator+=(const char* str);
		// insert()
		void insert(size_t pos, char ch);
		void insert(size_t pos, const char* str);
		// erase()
		void erase(size_t pos, size_t len = npos);
		// find()
		size_t find(char ch, size_t pos = 0);
		size_t find(const char* sub, size_t pos = 0);
		// substr()
		string substr(size_t pos = 0, size_t len = npos);
		// 比较大全
		bool operator<(const string& s) const;
		bool operator>(const string& s) const;
		bool operator<=(const string& s) const;
		bool operator>=(const string& s) const;
		bool operator==(const string& s) const;
		bool operator!=(const string& s) const;
		// clear()
		void clear();
	private:
		char* _str;  //字符串
		size_t _size;  //有效数据
		size_t _capacity;  //容量
		//存一个静态的npos，在类里面声明，在类外面定义，如果有多个文件，就都定义一遍，不然会发生链接错误
		//理论上来说静态成员变量是不可以在这里定义的，因为不走初始化列表，但是因为加了const，所以这里也可以直接赋值给-1
		//但是奇怪的是，只有整形可以遵循，换成其他的类型就会报错，所以还是不推荐这样写
		// const static double npos  //error
		const static size_t npos;
	};

	//流插入不适合写成成员函数，因为涉及到第一个位置的问题
	istream& operator<<(istream& is, string& str);
	ostream& operator>>(ostream& os, string& str);
}

//String.cpp
#define _CRT_SECURE_NO_WARNINGS 1
#include"String.h"
using namespace std;

//多个文件的命名空间会进行合并，与.h的合并，所以不需要声明命名空间
namespace bit
{
	//静态成员变量要在类外定义,而且不能加static，类里面的静态成员变量就相当于全局变量
	const size_t string::npos = -1;  //npos实际上是INT_MAX,由于它是size_t类型，所以-1就是最大值

	string::iterator string::begin()
	{
		return _str;
	}

	string::iterator string::end()
	{
		return _str + _size;
	}

	string::string()
	{
		_str = new char[1]{ '\0' };  //这里不能初始化为nullptr，比如c_str的返回类型是char*，所以要返回字符串，就会要找到'\0'才停止，就会崩溃，而且要保持和库里的一致
		_size = _capacity = 0;
	}

	string::string(const char* str)
		:_size(strlen(str))  //先初始化size，直接计算strlen，防止下面进行初始化的时候重复计算strlen
	{
		_str = new char[_size + 1];  //+1的目的是给'\0'留一个空间
		_capacity = _size;
		strcpy(_str, str);
	}

	string::string(const string& s)
	{
		_str = new char[s._capacity + 1];
		strcpy(_str, s._str);
		_size = s._size;
		_capacity = s._capacity;
	}

	//s1 = s3
	string& string::operator=(const string& s)
	{
		if (this != &s)
		{
			char* tmp = new char[s._capacity + 1];  //先建立新的字符串空间
			strcpy(tmp, s._str);  //拷贝到新的空间
			delete[] _str;  //释放旧的空间
			_str = tmp;
			_size = s._size;
			_capacity = s._capacity;
		}
		return *this;
	}

	string::~string()
	{   
		delete[] _str;
		_str = nullptr;
		_size = _capacity = 0;
	}

	const char* string::c_str() const  //写成const的好处是const对象和非const对象都可以调用
	{
		return _str;
	}

	size_t string::size() const
	{
		return _size;
	}

	char& string::operator[](size_t pos)
	{
		assert(pos < _size);
		return _str[pos];
	}

	void string::reserve(size_t n)
	{
		//相当于realloc
		if (n > _capacity)
		{
			char* tmp = new char[n + 1];  //在开空间的时候一定要预留一个空间给'\0'，因为'\0'是不算在capacity里面的
			strcpy(tmp, _str);  //先把数据给拷贝过去
			delete[] _str;  //释放原来的数组空间
			_str = tmp;  //新的_str就是tmp
			_capacity = n;  //容量也要改变
		}
		//如果不执行，就返回原来的容量大小，说明不需要扩容
	}

	void string::push_back(char ch)
	{
		//如果容量不够，就需要扩容
		if (_capacity == _size)
		{
			int newcapacity = _capacity == 0 ? 4 : _capacity * 2;
			reserve(newcapacity);
		}
		_str[_size] = ch;
		_str[_size + 1] = '\0';
		_size++;
	}

	void string::append(const char* str)
	{
		size_t len = strlen(str);
		//如果加上这个字符串的长度大于容量大小，说明需要扩容
		if (_size + len > _capacity)
			reserve(_size + len);
		//直接拷贝到末尾
		strcpy(_str + _size, str);  //这里也可以用strcat(_str, str);但是效率会比strcpy低,strcat是从头开始找'\0'才追加末尾，strcpy的直接拷贝，效率高的多
		_size += len;
	}

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

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

	void string::insert(size_t pos, char ch)
	{
		assert(pos <= _size);
		if (_capacity == _size)
		{
			int newcapacity = _capacity == 0 ? 4 : _capacity * 2;
			reserve(newcapacity);
		}
		for (int i = _size; i >= (int)pos; i--)  //这里pos原本是无符号整形，但i是有符号整形，有符号遇到无符号比较时，有符号会隐式类型转换成无符号，所以当i减到-1时会变成INT_MAX,所以为了避免这种情况，将pos强制转换成int比较即可
			_str[i + 1] = _str[i];				 //而对于将pos改成int类型，是可以的，但是为了和库里的一致，所以这样处理
		_str[pos] = ch;
		++_size;
	}

	void string::insert(size_t pos, const char* str)
	{
		assert(pos <= _size);
		size_t len = strlen(str);
		//扩容
		if (_size + len > _capacity)
			reserve(_size + len);
		for (int i = _size; i >= (int)pos; i--)
			_str[i + len] = _str[i];
		strncpy(_str + pos, str, len);  //这里不能用strcpy，原因是会把'\0'一起拷贝过去，也可以用memcpy
		_size += len;
	}

	void string::erase(size_t pos, size_t len)
	{
		assert(pos < _size);
		// len大于前面字符个数时，有多少删多少
		if (len >= _size - pos)  //这里不能写成pos + len >= _size,因为如果不传len的话，此时是npos，也就是size_t的最大值，再加就会出错
		{
			_str[pos] = '\0';
			_size = pos;
			//erase一般情况下不缩容
		}
		else
		{
			//直接拷贝复制
			strcpy(_str + pos, _str + pos + len);
			_size -= len;
		}
	}

	size_t string::find(char ch, size_t pos)
	{
		for (size_t i = pos; i < _size; i++)
		{
			if (_str[i] == ch)
				return i;
		}
		//没找到就返回npos
		return npos;
	}

	size_t string::find(const char* sub, size_t pos)
	{
		char* str = strstr(_str + pos, sub);
		return str - _str;  //字符串差值返回字符差距个数
	}

	string string::substr(size_t pos, size_t len)
	{
		assert(pos < _size);
		if (len >= _size - pos)
			return _str + pos;
		else
		{
			string str;
			str.reserve(len);
			for (size_t i = 0; i < len; i++)
				str += _str[pos + i];
			return str;
		}
	}

	bool string::operator<(const string& s) const
	{
		return strcmp(_str, s._str) < 0;  // 小于0就是小，就是真
	}

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

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

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

	bool string::operator==(const string& s) const
	{
		return strcmp(_str, s._str) == 0;
	}

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

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

	istream& operator<<(istream& is, string& str)
	{
		//跟库里的一致，会覆盖原来的字符串
		str.clear();
		char ch = is.get();  //调用get吃掉换行
		while (ch != ' ' && ch != '\n')
		{
			str += ch;
			ch = is.get();
		}
		return is;
	}

	ostream& operator>>(ostream& os, string& str)
	{
		for (size_t i = 0; i < str.size(); i++)
			os << str[i];
		return os;
	}
}

---

代码很多，string的常见操作基本都实现了，同学们细品之后是不是有所收获呢？咱们下期见咯！有疑问的可以在下方讨论，看见了就会回的！