class String
{
public:
	typedef char* Iterator;

public:
	String(const char* str = "")
	{
		if (nullptr == str)
		{
			assert(false);
			return;
		}

		_size = strlen(str);
		_capacity = _size;
		_str = new char[_capacity + 1];
		strcpy(_str, str);
	}

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

	String& operator=(const String& s)
	{
		if (this != &s)
		{
			char* pStr = new char[s._capacity + 1];
			strcpy(pStr, s._str);

			delete[] _str;
			_str = pStr;
			_size = s._size;
			_capacity = s._capacity;
		}

		return *this;
	}

	~String()
	{
		if (_str)
		{
			delete[] _str;
			_str = nullptr;
		}
	}

	Iterator Begin()
	{
		return _str;
	}

	Iterator End()
	{
		return _str + _size;
	}

	void PushBack(char c)
	{
		if (_size == _capacity)
			Reserve(_capacity * 2);

		_str[_size++] = c;
		_str[_size] = '\0';
	}

	void Append(size_t n, char c)
	{
		for (size_t i = 0; i < n; ++i)
			PushBack(c);
	}

	void Append(const char* str)
	{
		for (size_t i = 0; i < strlen(str); ++i)
			PushBack(str[i]);
	}

	String& operator+=(char c)
	{
		PushBack(c);
		return *this;
	}

	String& operator+=(const char* str)
	{
		for (size_t i = 0; i < strlen(str); ++i)
			PushBack(str[i]);
		return *this;
	}

	String& operator+=(const String& str)
	{
		size_t sz = str.Size();
		for (size_t i = 0; i < sz; ++i)
			PushBack(str[i]);
		return *this;
	}

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

	void Clear()
	{
		_size = 0;
		_str[_size] = '\0';
	}

	void Swap(String& s)
	{
		swap(_str, s._str);
		swap(_size, s._size);
		swap(_capacity, s._capacity);
	}

	size_t Size() const
	{
		return _size;
	}

	size_t Capacity() const
	{
		return _capacity;
	}

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

	void Resize(size_t newSize, char c = char())
	{
		if (newSize > _size)
		{
			// 若newSize大于底层空间大小，则需要重新开辟空间
			if (newSize > _capacity)
			{
				Reserve(newSize);
			}

			memset(_str + _size, c, newSize - _size);
		}

		_size = newSize;
		_str[newSize] = '\0';
	}

	void Reserve(size_t newCapacity)
	{
		// 若新容量大于旧容量，则开辟空间
		if (newCapacity > _capacity)
		{
			char* str = new char[newCapacity + 1];
			strcpy(str, _str);

			// 释放旧空间，使用新空间
			delete[] _str;
			_str = str;
			_capacity = newCapacity;
		}
	}

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

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

	// 返回c在string中第一次出现的位置
	size_t Find(char c, size_t pos = 0) const
	{
		for (size_t i = pos; i < _size; ++i)
		{
			if (c == _str[i])
			{
				return i;
			}
		}

		return string::npos;
	}

	// 返回子串s在string中第一次出现的位置
	size_t Find(const char* s, size_t pos = 0) const
	{
		size_t sz = strlen(s);

		if (sz > _size - pos)
			return string::npos;

		for (size_t i = pos; i < _size; ++i)
		{
			size_t j = 0;
			if (s[j] == _str[i])
			{
				for (j = 1; j < sz; ++j)
				{
					if (s[j] != _str[i + j])
						break;
				}
				if (j >= sz)
					return i;
			}
		}

		return string::npos;
	}

	// 截取string从pos位置开始的n个字符
	String SubStr(size_t pos, size_t n)
	{
		char* pStr = new char[n + 1];
		size_t i = 0;
		size_t j = pos;
		while (i < n)
		{
			if (j < _size)
				pStr[i++] = _str[j++];
			else
				break;
		}
		pStr[i] = '\0';

		String ret(pStr);
		return ret;
	}

	// 在pos位置上插入字符c
	String& Insert(size_t pos, char c)
	{
		String str = SubStr(pos, _size - pos);
		_str[pos] = c;
		_size = pos + 1