String类模拟

class String
{
	friend ostream& operator<<(ostream& _os, String& _s);//输出运算符重载
	friend istream& operator>>(istream& _is, String& _s);//输入运算符重载
public:
	String(char *str = "")
		: _p(new char[strlen(str) + 1])
		, sz(strlen(str))
		, capacity(strlen(str) + 1)
	{
		cout << "String()" << endl;
		strcpy(_p, str);
	}

	String(const String& s)
		: _p(new char[strlen(s._p) + 1])
		, sz(strlen(s._p))
		, capacity(strlen(s._p) + 1)
	{
		cout << "string(const String&)" << endl;
		strcpy(_p, s._p);
	}

	String& operator=(const String& s)
	{
		cout << "String& operator()" << endl;
		if (this != &s)
		{
			delete[] _p;
			_p = new char(strlen(s._p) + 1);
			strcpy(_p, s._p);
		}
		return *this;
	}

	//String& operator=(String s)
	//{
	//sz = s.sz;
	//capicity = s.capicity;
	//swap(_p, s._p);
	//return this;
	//}

	~String()
	{
		cout << "~String()" << endl;
		if (NULL != _p)
		{
			delete[] _p;
			_p = NULL;
			sz = 0;
			capacity = 0;
		}
	}

public:
	char *C_str()const
	{
		return _p;
	}

	void PushBack(char c)
	{
		GetCapacity(1);
		_p[sz++] = c;
		_p[sz] = '\0';
	}

	String& Insert(int pos, const String& s)
	{
		int count = strlen(s._p);
		if (pos <= sz)
		{
			GetCapacity(count);
			int j = sz + count;
			for (int i = sz; i >= pos; i--, j--)
			{
				_p[j] = _p[i];
			}
			strncpy(_p + pos, s._p, count);
		}
		sz += count;
		return *this;
	}

private:
	void GetCapacity(int count)              //得到扩容后的空间
	{
		if ((sz + count) >= capacity)      //如果总的字符数大于或等于容量，则扩容
		{
			int NewCapacity = (2 * capacity) > (capacity + count) ?
				(2 * capacity) : (capacity + count);
			char *tmp = new char[NewCapacity];
			strcpy(tmp, _p);
			delete[] _p;
			_p = tmp;
			capacity = NewCapacity;
		}
	}

private:
	char *_p;
	int sz;				//标记字符个数
	int capacity;		//标记字符容量
};

ostream& operator<<(ostream& _os, String& _s)
{
	_os << _s;
	return _os;
}
istream& operator>>(istream& _is, String& _s)
{
	_is >> _s;
	return _is;
}