模拟实现string类，以及增删查改各种功能

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

class String
{
public:
	//构造函数
	String(char *pstr = "")
		:_str(new char[strlen(pstr) + 1])
		, _size( strlen(pstr))
		, _capacity(_size)
	{
		strcpy(_str, pstr);
	}
	//拷贝构造函数-------传统法
	/*String(const String& s)
	:_str(NULL)
	{
	_str = new char[strlen(s._str) + 1];
	strcpy(_str, s._str);
	}*/
	//拷贝构造函数-------现代法
	String(const String& s)
		:_str(NULL)
		, _size(0)
		, _capacity(0)
	{
		String tmp(s._str);
		Swap(tmp);
	}
	//深拷贝赋值运算符重载
	String& operator= (String s)//请注意这里是形参拷贝，不是引用，
	{							//也就是说这个形参拷贝
		Swap(s);	    //出了这个作用域就会析构。
		return *this;           //交换后，this指针的_str就不用释放内存，因为
	}							//和形参拷贝交换后，形参出了作用域会被析构。
	~String()
	{
		if (_str)
		{
			delete[] _str;
			_str = NULL;
		}
	}
	void Swap(String& s)
	{
		swap(_str, s._str);
		swap(_size, s._size);
		swap(_capacity, s. _capacity);
	}
	/*void Display()
	{
		cout << _str << endl;
	}*/
	char* Getchar()
	{
		return _str;
	}


	// 增删查改 
	void PushBack(char ch)//尾插一个字符
	{
		if (_size == _capacity)
		{
			Expand(_capacity * 2);
		}
			_str[_size] = ch;
		    //_str[strlen(_str)] = ch;
			_size++;
			_str[_size] = '\0';
	}
	//尾插一个字符串
	void PushBack(const char* str)
	{
		if (_size + strlen(str) > _capacity)
		{
			Expand(_size + strlen(str));
		}
		strcpy(_str + _size, str);
		//_size += strlen(str);
		_size = strlen(_str);
	}
	//尾删一个字符
	void PopBack()
	{
		assert(_size > 1);
		strcpy(_str+_size-1, "\0");
		_size--;
	}
	//在pos位置插入字符ch
	void Insert(size_t pos, char ch)
	{
		if (_size == _capacity)
		{
			Expand(_capacity * 2);
		}
		//第一种
		/*char* tmp = new char[strlen(_str + pos) + 1];
		strcpy(tmp, _str+pos);
		strcpy(_str + pos + 1, tmp);
		_str[pos] = ch;
		_size++;*/
		//第二种
		for (size_t i = _size; i >= pos; i--)//因为在pos位置插入字符，因此pos位置的字符也要后移
		{
			_str[i + 1] = _str[i];
		}
		_str[pos] = ch;
		_size++;
	}
	//插入一个字符串
	void Insert(size_t pos, const char* str)
	{
		size_t len = strlen(str);
		if (_size + strlen(str) > _capacity)
		{
			Expand(_size + strlen(str));
		}
		/*char* tmp = new char[strlen(_str+pos) + 1];
		strcpy(tmp, _str + pos);
		strcpy(_str + pos + len, tmp); 
		strcpy(_str + pos, str);
		_size += len;*/
		for (int i = _size; i >= (int)pos; i--)
		{
			_str[i + len] = _str[i];
		}
		while (*str)
		{
			_str[pos++] = *str++;
		}
		_size += len;
	}
	//删除pos位置的字符，以及删除几个字符
	void Erase(size_t pos, size_t count)
	{
		assert(_size > count);
		if (pos + count > _size)//pos位置后的字符数没有count个
		{
			_str[pos] = '\0';
			_size = pos;
		}
		//第一种
		/*char* tmp = new char[strlen(_str + pos + count) + 1];
		strcpy(tmp, _str + pos + count);
		strcpy(_str + pos, tmp);
		_size -= count;*/
		//第二种
		else//pos后面的字符个数有count个
		{
			int len = strlen(_str + pos + count);
			while (len--)
			{
				_str[pos++] = _str[pos++ + count];
			}
			_size -= count;
			_str[_size] = '\0';
		}
	}
	//查找字符，count从1开始。
	int Find(char ch) const
	{
		//int count = 0;
		//char* tmp = _str;
		//while (*(tmp))
		//{
		//	count++;
		//	if (*tmp == ch)
		//	return count;//hello
		//	tmp++;
		//}
		//return -1;
		for (size_t i = 0; i < _size; i++)
		{
			if (_str[i] == ch)
			{
				return i;
			}
		}
	}
	//查找子字符串
	int Find(const char* str) const
	{
		char* _str_tmp = _str;
		char* str_tmp = (char*)str;
		int count = 0;
		while (*_str_tmp != '\0')
		{
			count++;
			char* tmp = _str_tmp;
			while (*tmp == *str_tmp && *tmp)
			{
				tmp++;
				str_tmp++;
				if (*str_tmp == '\0')
				{
					return count;
				}
			}
			str_tmp = (char*)str;
			_str_tmp++;
		}
		//const char* srcStr = _str;//父串
		//const char* subStr = str;//子串
		//size_t subLen = strlen(subStr);//子串长度
		//size_t srcIndex = 0;
		//size_t subIndex = 0;
		//while (srcIndex < _size - subLen - 1)
		//{
		//	size_t matchIndex = srcIndex;
		//	while (srcStr[matchIndex] == subStr[subIndex])
		//	{
		//		++matchIndex;
		//		++subIndex;


		//		if (subIndex == subLen)
		//			return srcIndex;
		//	}


		//	subIndex = 0;
		//	srcIndex++;
		//}
		return -1;
	}
	char& operator[](size_t pos)
	{
		assert(pos > 0 &&pos < _size);
		return _str[pos];
	}
	bool operator>(const String& s) const
	{
		char* _str_tmp = _str;
		char* _s_tmp = s._str;
		while (*_str_tmp++ && *_s_tmp++)
		{
			if (*_str_tmp > *_s_tmp)
			{
				return true;
			}
			else if (*_str_tmp < *_s_tmp)
			{
				return false;
			}
		}
		if (strlen(_str) > strlen(s._str))
		{
			return true;
		}
		else
		{
			return false;
		}
	}
	bool operator<=(const String& s) const
	{
		return !(*this > s);
	}
	bool operator<(const String& s) const
	{
			char* _str_tmp = _str;
			char* _s_tmp = s._str;
			while (*_str_tmp++ && *_s_tmp++)
			{
				if (*_str_tmp < *_s_tmp)
				{
					return true;
				}
				else if (*_str_tmp < *_s_tmp)
				{
					return false;
				}
			}
			if (strlen(_str) < strlen(s._str))
			{
				return true;
			}
			else
			{
				return false;
			}
		}
	bool operator>=(const String& s) const
	{
		return !(*this < s);
	}
	//通过代码的服用可以减少很多不必要的代码
	bool operator==(const String& s) const
	{
		return !((*this < s) || (*this > s));
	}
	bool operator!=(const String& s)const;
	void Expand(size_t n)//增容
	{
		if (n > _capacity)
		{
			_str = (char*)realloc(_str,n*(sizeof(char))+1);
			assert(_str);
			_capacity = n;
		}
	}
private:
	char* _str;
	size_t _size;//字符个数
	size_t _capacity;//容量大小
};
int main()
{
	String s1("aabda");
	String s2("aabd");
	/*cout << s1.Getchar() << endl;
	s1.PushBack('m');
	cout << s1.Getchar() << endl;
	s1.PushBack("wor96969");
	cout << s1.Getchar() << endl;
	s1.PopBack();
	cout << s1.Getchar() << endl;
	s1.Insert(5,'a');
	cout << s1.Getchar() << endl;*/
	/*s1.Insert(2,"adaadad");
	cout << s1.Getchar() << endl;*/
	/*s1.Erase(2, 2);
	cout << s1.Getchar() << endl;*/
	/*cout << s1.Find('l') << endl;*/
	/*cout << s1.Find("abaaddddd") << endl;*/
	cout <<( s1 == s2 )<< endl;
	return 0;
}