相信都用过stl里面的std::string 类，现在我们尝试一下实现自己的string类。

首先进行分析，我们需要一个数组或者指针来保存字符串，

还需要一个成员变量表示长度，

另外还需要一个成员变量表示总的分配的数组空间的大小。

需要实现哪些功能点？

1.stl迭代器的功能begin(),end()这种

2.能够通过[]进行str[3],str[4]这种，输出对应的字符

3.能够使用赋值运算符

4.能够直接输出里面的内容

5.内容重新分配内存的空间大小

简单的实现功能

1.因为我们有成员变量size 表示数组的长度，可以简单找到头尾的位置。

2.重载[]操作符

3.重载=符号

4.遍历数组里面的字符进行输出

5.根据输入的参数，创建新的空间，把旧的字符拷贝过去然后删除旧的空间

6.充分的利用strlen ,strcpy  new 这几个函数和操作符。

具体实现

#include <string.h>
#include <iostream>
#include <assert.h>
class MyString
{
public:

	MyString();
	MyString(const char* str) {
		_size = strlen(str);
		_str = new char[_size + 1];
		_capacity = _size;
	}
	~MyString();
public:
	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;
	}

public:
	
	char& operator[](size_t pos) {
		assert(pos < _size);
		return _str[pos];
	}
	MyString(const MyString& string) {
		_size = string._size;
		_str = new char[_size + 1];
		strcpy_s(_str, _size + 1, string._str);
		_capacity = _size;
	}

	MyString& operator=(const MyString& string) {
		if (this != &string)
		{
			delete[] _str;
			_capacity = _size = string._size;
			_str = new char[_size + 1];
			strcpy_s(_str, _size + 1, string._str);
		}

		return *this;
	}
	void print(const MyString& str)
	{
		MyString::const_iterator it = str.begin();

		while (it != str.end())
		{
			std::cout << *it;
			it++;
		}
	}

	void reserve(size_t n)
	{
		if (n > _capacity)
		{
			char* tmp = new char[n + 1];
			strcpy_s(tmp, _size,_str);
			delete[] _str;
			_str = tmp;
		}

		_capacity = n;
	}

	void resize(size_t n, char str = '')
	{
		if (n <= _size)
		{
			_size = n;
			_str[n] = '';
		}
		else
		{
			if (n > _capacity)
			{
				reserve(n);
			}

			for (size_t m = _size; m < n; m++)
			{
				_str[m] = str;

			}

			_size = n;
			_str[_size] = '';
		}
	}

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