再谈STL中string类——模拟实现

之前在和友友们与STL中的string类“见面交流”，不得不说在字符串的相关问题上，string类中强大的接口使我们用起来非常的方便。但我认为，我们作为C++的学习爱好者，不能仅仅止步于此，运用它只是第一步，更重用要的是要深入去理解它！！！
如果还没有与string类见过面的友友可以点下面，先和它见个面吧。
悄悄告诉你，小手手点这里哦！

说了这么多“废话”，现在就让我们一起来自己动手来模拟实现它吧！

#include<iostream>
#include<assert.h>
using namespace std;

namespace RH
{
	class string
	{
		friend ostream& operator<<(ostream& _cout, const RH::string& s)
		{
			for (auto ch : s)
			{
				_cout << ch;
			}
			return _cout;
		}
		friend istream& operator>>(istream& _cin, RH::string& s)
		{
			s.clear();
			char ch;
			ch = _cin.get();
			while (ch != ' '&&ch != '\0')
			{
				s += ch;
				ch = _cin.get();
			}
			return _cin;
		}
	public:
		typedef char* iterator;
	public:
		string(const char* str = "")
			:_str(new char[strlen(str)+1])
		{
			strcpy(_str, str);
		}
		string(const string& s)
			:_str(nullptr)
		{
			string temp(s._str);
			swap(temp);
		}
		string operator=(string s)
		{
			swap(s);
			return *this;
		}
			~string()
			{
				delete[] _str;
				_str = nullptr;
			}
		//
		// iterator迭代器实现
			iterator begin()
			{
				return _str;
			}
			iterator end()
			{
				return _str+_size;
			}
	    //尾插单个字符
			void push_back(char c)
			{
				if (_size == _capacity)
				{
					reserve(_capacity * 2);
				}
				_str[_size] = c;
				_str[_size + 1] = '\0';
				++_size;
			}
			string& operator+=(char c)
			{
				push_back(c);
				return *this;
			}
			//尾插字符串
		void append(const char* str)
		{
			size_t len = strlen(str)+_size;
			if (len > _capacity)
			{
				reserve(len);
			}
			strcpy(_str + _size, str);
			_size = len;
		}
		string& operator+=(const char* str)
		{		
			append(str);
			return *this;
		}
		//清理之前的字符串内容
		void clear()
		{
			_size = 0;
			_str[0] = '\0';
		}
		//字符串交换
		void swap(string& s)
		{
			::swap(_str, s._str);
			::swap(_size, s._size);
			::swap(_capacity, s._capacity);
		}
		const char* c_str()const
		{
			return _str;
		}
		/
		size_t size()const
		{
			return strlen(_str);
		}
		size_t capacity()const
		{
			return strlen(_str);
		}
		bool empty()const
		{
			if (_str == nullptr)
				return true;
			else
				return false;
		}
		//resize增容
		void resize(size_t n, char c = '\0')
		{
			if (n<_size)
			{
				_size = n;
				_str[_size] = '\0';
			}
			else
			{
				if (n < _capacity)
				{
					reserve(n);
				}
				for (size_t i = _size; i < n; i++)
				{
					_str[i] = c;
				}
				_str[n] = '\0';
				_size = n;
			}
		}
		//reserve增容实现
		void reserve(size_t n)
		{
			if (n > _capacity)
			{
				char* temp = new char[n + 1];
				strncpy(temp, _str,_size+1);
				delete[] _str;
				_str = temp;
			}
		}
		/
		//运算符[]重载
		char& operator[](size_t index)
		{
			assert(index < _size);    //断言防止输入不合法用例
			return _str[index];
		}
		const char& operator[](size_t index)const
		{
			assert(index < _size);
			return _str[index];
		}
		/
		//六种比较判断符的重载实现
		bool operator<(const string& s)
		{
			if ((s._str-_str)<0)
			{
				return true;
			}
			return false;
		}
		bool operator<=(const string& s)
		{
			if (s._str>_str)
			{
				return false;
			}
			return true;
		}
		bool operator>(const string& s)
		{
			if ((s._str - _str)>0)
			{
				return true;
			}
			return false;
		}
		bool operator>=(const string& s)
		{
			if (s._str<_str)
			{
				return false;
			}
			return true;
		}
		bool operator==(const string& s)
		{
			if ((s._str - _str) == 0)
			{
				return true;
			}
			return false;
		}
		bool operator!=(const string& s)
		{
			if (s._str == _str)
			{
				return false;
			}
			return true;
		}
		// 返回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;//找不到时返回-1
			}
		}
		// 返回子串s在string中第一次出现的位置
		size_t find(const char* s, size_t pos = 0) const
		{
			assert(pos < _size);
			const char* ret = strstr(_str + pos, s);
			if (ret)
			{
				return ret - _str;
			}
			else
			{
				return npos;
			}
		}
		// 在pos位置上插入字符，并返回该字符的位置
		string& insert(size_t pos, char c)
		{
			assert(pos < _size);
			if (_capacity == _size)
			{
				reserve(_capacity == 0 ? 4 : _capacity * 2);
			}
			char* end = _str + _size;
			while (end>_str + pos)
			{
				*end = *(end + 1);
				--end;
			}
			_str[pos] = c;
			_size++;
			return *this;
		}
		// 在pos位置上插入字符串str，并返回该字符的位置
		string& insert(size_t pos, const char* str)
		{
			assert(pos <= _size);
			size_t len = strlen(str);
			if (_size + len > _capacity)
			{
				reserve(_size + len);
			}
			char* end = _str + _size;
			while (end >= _str + pos)
			{
				*end = *(end + 1);
				end--;
			}
			strncpy(_str + pos, str, len);
			_size += len;
			return *this;
		}
		// 删除pos位置上的元素，并返回该元素的下一个位置
		string& erase(size_t pos, size_t len)
		{
			assert(pos < _size);
			size_t leftLen = _size - pos;
			if (len>=leftLen)
			{
				_str[pos] = '\0';
				_size = pos;
			}
			else
			{
				strcpy(_str + pos, _str + pos + len);
				_size -= len;
			}
			return *this;
		}
	private:
		char* _str;
		size_t _capacity;
		size_t _size;
		static const size_t npos;
	};
	static const size_t npos = -1;
}

今天的内容就到这里了哈！！！ 要是认为作者有一点帮助你的话！ 就来一个点赞加关注吧！！！当然订阅是更是求之不得！ 最后的最后谢谢大家的观看！！！ 你们的支持是作者写作的最大动力！！！ 下期见哈！！！