【C++】string类的模拟实现（增删查改，比大小，运算符重载）

1.1大框架

namespace simulation {
	class string {
	public:
 //成员函数：

	private:
		size_t _size;
		//当前长度
		size_t _capacity;
		//最大容量，不包括'\0'
		char* _str;
		const static size_t npos;
		//表示一个特殊的无效位置（无效的字符串索引或子字符串位置）
		//定义为一个静态常量，具体的值是一个特别大的整数，通常被定义为-1。
	};
	const size_t string::npos=-1;	 
}

1.2基本函数：

const char* c_str()const {
			return _str;
			//打印字符
		}

		size_t size() {
			return _size;
			//字符串长度
		}

		char& operator[](size_t pos) {//可读写
			assert(pos < _size);
			return _str[pos];
		}
		const char& operator[](size_t pos) const{//只可读
			assert(pos < _size);
			return _str[pos];
		}

2.成员函数

2.0构造函数

//构造函数：
		//方法一：无参和有参分开讨论
		string()
			//运用初始化列表
			:_size(0)
			, _capacity(0)
			, _str(new char[1])
		{
			_str[0] = '\0';
		}

		string(const char* str)
			:_size(strlen(str))
			, _capacity(_size)
			, _str(new char[_capacity + 1])
		{
			memcpy(_str, str, _size + 1);
		}
//方法二：直接用缺省参数合并两种情况
		string(const char* str = "") {
			_size = strlen(str);
			_capacity = _size;
			_str = new char[_capacity + 1];
			//开空间要比_capacity多一个，因为
			//capacity的大小不包括'\0'，所以我们要自己加
			memcpy(_str, str, _size + 1);
			//拷贝的字节数为_size + 1是因为我们要算上'\0'
		}

2.05析构函数

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

2.09拷贝构造函数

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

补充：预留存储空间（reserve）

void reserve(size_t n) {
			if (n > _capacity) {
				char* tmp = new char[n + 1];
				//要包括'\0'的大小所以要+1
				memcpy(tmp, _str, _size + 1);
				//将原字符拷贝到新空间
				delete[] _str;
				_str = tmp;
				_capacity = n;
				//改变最大容量
			}
		}

2.1增加字符（push_back，append，s+=）

push_back

void push_back(char ch) {
			if (_size == _capacity) {
				reserve(_capacity == 0 ? 4 : 2 * _capacity);
				//检查容量是否够
			}
			_str[_size] = ch;
			++_size;
			_str[_size] = '\0';
		}

append

void append(const char* str) {
			size_t  len = strlen(str);
			if (len + _size > _capacity) {
				//检查容量是否够
				reserve(len + _size);//扩容
			}
			memcpy(_str + _size, str, len + 1);
			//从末尾开始拷贝，len个字符再加上'\0'
			_size += len;
		}

s+=

string& operator+=(const char* str) {
			//加字符串
			append(str);
			return *this;
		}

		string& operator+=(char ch) {
			//只加一个字符
			push_back(ch);
			return *this;
		}

2. 删除字符（erase）

void erase(size_t pos, size_t len = npos) {
			assert(pos <= _size);
			if (len == npos || len + pos >= _size) {
				//要删除长度等于当前最大长度
				//或从删除位置开始加上要删除的长度
				//大于等于当前最大长度

				//相当于直接把pos朝后面的都删完
				_size = pos;
				_str[_size] = '\0';
				
			}
			else {
				size_t end = pos + len;
				//从要删除的数据后一个开始即end
				//移动到pos位置
				while (end<=_size) {
					_str[pos++] = _str[end++];
				}
				_size -= len;
			}
		}

2. 查找字符（find）

size_t find(char ch, size_t pos=0) {
			//查找字符
			assert(pos < _size);
			for (size_t i = 0; i < _size; i++) {
				if (_str[i] == ch) {
					return i;
				}
			}
			return npos;
		}

		size_t find(const char* str, size_t pos = 0) {
			//查找字符串
			assert(pos < _size);
			const char* ptr = strstr(_str, str);
			if (ptr) {
				return ptr - _str;
				//两个指针相减即两指针相距的元素个数
				//_str下标为0
			}
				return npos;
		}

2. 插入字符（insert）

void insert(size_t pos, size_t n, char ch) {
			assert(pos <= _size);
			if (n + _size > _capacity) {
				reserve(n + _size);
			}
			size_t end = _size;
			//方法一*while (end >= (int)pos) {会发生整形提升
			// 所以要把pos强转要不会死循环
				//_str[end + n] = _str[end];
				//end--;
			//}*/

			while (end >= pos && end != npos) {//方法二
				_str[end + n] = _str[end];
				end--;
			}
			for (size_t i = 0; i < n; i++) {
				_str[pos + i] = ch;
			}
			_size += n;
		}

		void insert(size_t pos, const char* str) {
			assert(pos <= _size);
			size_t  len = strlen(str);
			if (len + _size > _capacity) {
				// 至少扩容到_size + len
				reserve(len + _size);
			}
			size_t end = _size;
			//从最后一个位置，将end与pos之间
			//的字符都朝后面移动len个单位
			while (end >= pos&&end!=npos) {
				_str[len + end] = _str[end];
				end--;
			}
			for (size_t i = 0; i < len; i++) {
				_str[pos + i] = str[i];
			}
			//将要插入字符串放入
			_size += len;

		}

2. 截取字符（substr）

string  substr(size_t pos=0, size_t len = npos) {
			assert(pos < _size);
			size_t n = len;
			//判断要截取长度大小
			//看是否要pos之后截取全部
			if (len == npos || len + pos > _size) {
				n = _size - pos;
			}
			string tmp;
			tmp.reserve(n);//扩容
			for (size_t i = pos; i < pos + n; i++)
			{
				tmp += _str[i];
			}
			return tmp;
		}

2. 调整字符串的长度（resize）

void resize(size_t n,char ch='\0') {
			if (n < _size) {
				//如果n小于当前长度，则字符串被截断
				_str[n] = '\0';
				_size = n;
			}
			else {
				//如果n大于当前长度，则字符串被填充到指定长度并用ch进行填充。
				reserve(n);
				for (size_t i = _size; i < n; i++) {
					_str[i] = ch;
				}
				_size = n;
				_str[_size] = '\0';
			}
		}

2. 比大小（运算符重载）

<

//方法一
		bool operator<(const string& s)const {
			int i1 = 0;
			int i2 = 0;
			while (i1 < _size && i2 < s._size) {
				if (_str[i1] < s._str[i2]) {
					return true;
				}
				else if (_str[i1] > s._str[i2]) {
					return false;
				}
				else {
					i1++;
					i2++;
				}
			}
			// "hello" "hello"   false
			// "helloxx" "hello" false
			// "hello" "helloxx" true
			return _size < s._size;
		}
		//方法二：精简版
		bool operator<(const string& s)const {
			int ret = memcmp(_str, s._str, _size < s._size ? _size : s._size);
			return ret == 0 ? _size < s._size : ret < 0;
		}
		 

复用

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

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

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

2.流插入提取（cout，cin）

cout

ostream& operator<<(ostream& out, const simulation::string& s)
{
	for (auto ch : s)
	{
		out << ch;
	}

	return out;
}

cin

void clear() {
			_str[0] = '\0';
			_size = 0;
		}
``istream& operator>>(istream& in,  simulation:: string& s) {
	s.clear();
	//清除缓冲区
	char ch = in.get();
	// 处理前缓冲区前面的空格或者换行
	while (ch == ' ' || ch== '\n') {
		ch = in.get();
	}
	char buff[128];
	//有了初始空间可避免反复扩容
	int i = 0;
	while (ch != ' ' && ch != '\n') {
		buff[i++] = ch;
			if (i == 127) {
				buff[i] = '\0';
				s += buff;
				i = 0;
			}
			ch = in.get();
	}
	if (i != 0) {
		buff[i] = '\0';
		s += buff;
	}
	return in;
} 

2.赋值运算符重载

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

		string& operator=(string tmp) {
			swap(tmp);
			return *this;
		}

2.迭代器

       typedef char* iterator;
		typedef const char* const_iterator;
		
		iterator begin() {
			return _str;
		}

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