作者：洪春涛 链接：https://www.zhihu.com/question/25536695/answer/221638079 来源：知乎 著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。 
	

class String
{
private:
	char* _ptr;
	size_t _size;
	size_t _capacity;
	static size_t npos;
public:
	String()//无参构造，开辟一个字节空间
		:_ptr(new char[1])
		, _size(0)
		, _capacity(0)
	{
		*_ptr = '\0';
	}
	String(const char* ptr)//带参构造
		:_ptr(new char[strlen(ptr)+1])
		,_size(0)
		,_capacity(0)
	{
		strcpy(_ptr, ptr); //重新开辟空间 进行字符串拷贝
		_size =_capacity= strlen(_ptr);
	}
	//此处复用带参构造开辟一个临时对象，进行交换
	String(const String& str)//拷贝构造 
		:_ptr(nullptr)
		,_size(0)
		,_capacity(0)
	{
		String tmp(str._ptr);
		Swap(tmp);
	}
	//此处复用拷贝构造创建临时对象str，进行交换
	String& operator=(String str)//赋值运算符
	{
		Swap(str);
		return *this;
	}
	const char& operator[](size_t n) const
	{
		assert(n < _size);
		return _ptr[n];
	}

	//增容，注意循环进行拷贝，释放原有空间
	void reserve(size_t n)
	{
		if (n > _capacity)
		{
			char* str = new char[n+1];//开新的空间
			//拷贝内容，这里有bug，拷贝不到 /0
			//strcpy(str, _ptr);
			for (size_t i=0;i<_size;i++)
			{
				str[i] = _ptr[i];
			}
			delete[] _ptr;
			_ptr = str;
			_capacity = n;
		}
	}
	//大于原有空间需要增容，空间够用需要用ch填充（memset函数）
	void resize(size_t n,char ch='\0')
	{
		if (n > _capacity)
		{
			reserve(n);
		}
		if (n > _size)
		{
			memset(_ptr + _size, ch, n - _size);
		}

		_size = n;
		_ptr[_size] = '\0';
	}
	//判断是否增容
	void push_back(const char& ch)
	{
		if (_size == _capacity)
		{
			size_t new_capacity=_capacity == 0 ? 15 : 2 * _capacity;
			reserve(new_capacity);
		}
		_ptr[_size] = ch;
		_size++;
		_ptr[_size] = '\0';
	}
	//析构
	~String()
	{
		if (_ptr)
		{
			delete[] _ptr;
			_ptr = nullptr;
			_size = _capacity = 0;
		}
	}
	size_t size() const 
	{
		return _size;
	}
	size_t capacity() const
	{
		return _capacity;
	}
	void Swap(String& str)
	{
		swap(_ptr, str._ptr);
		swap(_size, str._size); 
		swap(_capacity, str._capacity);
	}
	void append(const char* str)
	{
		int len = strlen(str);
		if (len + _size > _capacity)
		{
			reserve(_size+len );
		}
		//尾插字符串
		//strcpy(_ptr+_size,str);
		_ptr[len + _size] = '\0';
		while (len)
		{
			_ptr[len + _size-1] = str[len-1];
			len--;
		}
		_size += strlen(str);
	}
	String& operator+=(const char& ch)
	{
		this->push_back(ch);
		return *this;
	}	
	String& operator+=(const char* str)
	{
		this->append(str);
		return *this;
	}
	String& operator+=(const String& str)
	{
		append(str._ptr);
		return *this;
	}
	//插入一个字符
	void insert(size_t pos, const char& ch)
	{
		assert(pos <= _size);
		if (_size == _capacity)
		{
			size_t newc = _capacity == 0 ? 15 : 2 * _capacity;
			reserve(newc);
		}
		size_t end = _size;
		while (end-pos)
		{
			_ptr[ end ] = _ptr[end - 1];
			--end;
		}
		_ptr[pos] = ch;
		_ptr[++_size] = '\0';
	}
	
	//插入一个字符串
	void insert(size_t pos, const char* str)
	{
		assert(pos <= _size);
		int len = strlen(str);
		if (_size + len > _capacity)
		{
			reserve(_size + len);
		}
		size_t end = _size + len;
		while (end>pos+len-1)
		{
			_ptr[end] = _ptr[end - len];
			--end;
		}
		memcpy(_ptr + pos, str, len);
		_size += len;
		_ptr[_size] = '\0';
	}
	//删除指定位置指定长度
	void erase(size_t pos,size_t len)
	{
		assert(pos < _size&&pos>=0);
		if (pos + len >= _size)
		{
			_ptr[pos] = '\0';
			_size = pos;
			return;
		}
		size_t start = pos + len;
		while (start<_size)
		{
			_ptr[pos++] = _ptr[start++];
		}
		_size -= len;
		_ptr[_size] = '\0';
	}
	size_t find(const char& ch, size_t pos=0)
	{
		assert(pos < _size);
		while (pos < _size)
		{
			if (_ptr[pos] == ch)
			{
				return pos;
			}
			pos++;
		}
		return npos;
	}
	size_t find(const char* str, size_t pos=0)
	{
		assert(pos < _size);
		char* s=strstr(_ptr+pos, str);
		if (s)
		{
			return s - _ptr;
		}
		return npos;
	}
	typedef char* iterator;
	typedef const char* const_iterator;
	iterator begin()//第一个元素的位置
	{
		return _ptr;
	}
	iterator end()
	{
		return _ptr + _size;
	}
	const_iterator begin() const//第一个元素的位置
	{
		return _ptr;
	}
	const_iterator end() const //最后一个元素的下一个位置
	{
		return _ptr + _size;
	}
	friend ostream& operator<<(ostream& out, const String& str);
	friend istream& operator>>(istream& in, String& str);

};

_{C++构造函数之委托构造函数}