C++中string的模拟实现代码（纯代码）

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

const int npos = -1;

class string
{
public:


	string(const char* str = "")
		:
		_size(strlen(str))
	{
		_capacity = _size;
		_str = new char[_size + 1];//+1是为了存储\0
		strcpy(_str, str);
	}

	string(const string& obj)
	{
		_str = new char[obj._capacity];
		strcpy(_str, obj._str);
		_size = obj._size;
		_capacity = obj._capacity;
	}

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

	string& operator =(const string& obj)
	{
		if (_str != nullptr)
		{
			delete[] _str;
		}
		_str = new char[obj._capacity];
		strcpy(_str, obj._str);
		_size = obj._size;
		_capacity = obj._capacity;
	}

	//==================================================================================

	typedef char* iterator;
	typedef const char* const_iterator;

	iterator begin()
	{
		return _str;
	}

	iterator end()
	{
		return _str + _size;
	}

	const_iterator begin() const
	{
		return _str;
	}

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


	//====================================================

	void Push_back(const char ch)
	{
		if (_size == _capacity)
		{
			reserve(_capacity == 0 ? 4 : _capacity * 2);
		}
		_str[_size] = ch;
		_size++;
		_str[_size] = '\0';
	}

	string& operator+=(const char ch)
	{
		if (_size == _capacity)
		{
			reserve(_capacity == 0 ? 4 : _capacity * 2);
		}
		_str[_size++] = ch;
		_str[_size] = '\0';
		return *this;
	}

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

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


	void Clear()
	{
		delete[] _str;
		_str = nullptr;
		_size = 0;
		_capacity = 0;
	}

	void Swap(string& s)
	{
		char* Temp = this->_str;
		this->_str = s._str;
		s._str = Temp;

		size_t Temp1 = this->_size;
		this->_size = s._size;
		s._size = Temp1;

		Temp1 = this->_capacity;
		this->_capacity = s._capacity;
		s._capacity = Temp1;

	}

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

	//===========================================================

	size_t Size()const
	{
		return _size;
	}

	size_t Capasize()const
	{
		return _capacity;
	}

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

	void resize(size_t n, char c = '\0')
	{
		if (n >= _size)
		{
			for (int i = _size; i < n; i++)
			{
				if (_size == _capacity)
				{
					reserve(_capacity == 0 ? 4 : _capacity * 2);
				}
				_str[i] = c;
			}
		}
		_str[n] = '\0';
		_size = n;
	}

	void reserve(size_t New_capacity)
	{
		if (New_capacity > _capacity)
		{
			char* Temp = new char[New_capacity + 1];
			_capacity = New_capacity;
			strcpy(Temp, _str);
			delete[] _str;
			_str = Temp;
		}

	}

	//================================================================

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

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

	//===================================================================

	void Pop_back()
	{
		if (_size == 0 || _capacity == 0)
		{
			return;
		}
		_str[_size - 1] = '\0';
		_size--;
	}




	//====================================================

	bool operator <(const string& s)
	{
		if (strcmp(_str, s._str) < 0)
		{
			return true;
		}
		else
		{
			return false;
		}
	}

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


	bool operator >(const string& s)
	{
		if (strcmp(_str, s._str) > 0)
		{
			return true;
		}
		else
		{
			return false;
		}
	}

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

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

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

	size_t Find(char c, size_t pos = 0) const
	{
		if (pos > _size)
		{
			return npos;
		}
		const_iterator i = begin() + pos;
		while (i != end())
		{
			if (*i == c)
			{
				return pos;
			}
			pos++;
			i++;
		}
		return npos;
	}



	size_t Find(const char* s, size_t pos = 0) const
	{
		if (pos > _size)
		{
			return npos;
		}
		const_iterator it = begin() + pos;
		while (it != end())
		{
			if (*it == s[0])
			{
				size_t Tem = 1;
				for (size_t i = 1; i + pos < _size; i++)
				{
					if (s[i] == '\0')
					{
						return pos;
					}
					else if (s[i] == *(it + Tem))
					{
						Tem++;
						continue;
					}
					else
					{
						break;
					}

				}

			}
			pos++;
			it++;
		}
		return npos;
	}

	string& insert(size_t pos, char c)
	{
		assert(pos > _size);
		if (_size + 1 >= _capacity)
		{
			reserve(_capacity == 0 ? 4 : _capacity * 2);
		}
		for (int i = _size; i > pos; i--)
		{
			_str[i] = _str[i - 1];
		}
		_str[pos] = c;
		_size++;
		return *this;
	}

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


	void erase(size_t pos, int len = npos)//pos是指删除的位置，len是删除的长度
	{
		assert(pos < _size);
		if (len == npos || pos + len >= _size)//保证不会后续pos和len指向的范围都在有效字符串内
		{
			_str[pos] = '\0';
			_size = pos;
			return;
		}

		for (int i = 0; i < len; i++)
		{
			for (int j = pos; j < _size - i - 1; j++)
			{
				_str[j] = _str[j + 1];

			}
		}
		_str[_size - len] = '\0';
		_size -= len;
	}

	void text(const string& str);



private:
	char* _str;
	size_t _size;
	size_t _capacity;
};