初级C++：string类的实现

• 构造函数 、深度拷贝构造、swap
• resize 、 reserve
• 重载 [ ] 访问、 赋值重载 =
• += 重载、 c_str
• getinline
• 输入输出操作符重载：<< 、>>

string(const char* s)
	:_size(strlen(s))	/防止是无参空串 ，先测长度
	, _cap(_size)
{
	_a = new char[_cap + 1];
	strcpy(_a, s); 		/字符串拷贝到实例化的新对象这里
}
--------------------------------------------------Swap
void swap(string& s)
{
算法里面的swap
	::swap(_a, s._a);
	::swap(_size, s._size);
	::swap(_cap, s._cap);
}

template  /简单的swap模板
void swap(T &a, T &b)   
{
    T temp = a;
    a = b;
    b = temp;
}
---------------------------------------------深度拷贝构造
string(const string& s)
	:_a(nullptr)
{
	string tmp(s._a);      临时tmp出了这个域自动析构
	/ ===  this->swap(tmp)
	swap(tmp);
}

size开空间，并初始化；serve只对cap扩容负责

void resize(size_t n, char ch='0')
{
	/小于直接腰斩
	if (n<=_size)
	{
		_size = n;
		_a[_size] = '';  /不传默认用 0 
	}
	else
	{
		if (n>_cap)
		{
			reserve(n);     /开n个就好了
		}
		for (size_t i = _size; i < n; i++)
		{
			_a[_size] = ch;   /新开的初始化
		}
		_size = n;
		_a[_size] = '';
	}
}
---------------------------------------------Reserve
void  reserve(size_t n)
{
	/开辟一块儿新的空间，拷贝源空间，销毁原空间
	if (n>_cap)
	{
		char* tmp = new char[n + 1];
		strcpy(tmp, _a);
		delete[] _a;
		_a = tmp;
		/size  没变 容量变化了
		_cap = n;
	}
}

字符串数组访问，返回字符

char& operator[](size_t pos)
{
	assert(pos < _size);
	return _a[pos];//*(a+pos)
}

只读的
const char& operator[](size_t pos)const
{
	assert(pos < _size);
	return*(_a + pos); /_a[pos];
}
-----------------------------------------------------赋值重载
string& operator=(const string& s)
	{
		if (this != &s)
			{
			string tmp(s._str);
			swap(_str, tmp._str);
			}

			return *this;
	}

/字符 
string& operator+=(char ch)
{
	string::push_back(ch);
	return *this;
}
/字符串
string& operator+=(const char* s)
{
	string::append(s);
	return *this;
}
void append(const char* s)
{
	/追加的字符串的长度
	size_t len = strlen(s);
	if (_size+len>=_cap)          /大于容量,扩容
	{
		reserve(_size + len);
	}
	/原字符长度尾部开始复制
	strcpy(_a + _size, s);
	_size += len;
}
字符串对象
string&  operator+=(const string& s)
{
	*this += s._a;
	return *this;
}
--------------------------------------------C_str
/c_str,返回对象的字符串
const char* c_str()
		{
			return _str;
		}

从输入流输入数据，存到对象里，遇到’n’结束输入

/输入流的类型
istream& getline(istream& in, string& s)
	{
		s.clear();
		char ch = in.get();
		while (ch != 'n')
		{
			s += ch;
			ch = in.get();
		}
		return in;
	}

	void test_string6()
	{
		string s1;
		getline(cin, s1);
		cout << s1 << endl;
	}

输入
	istream& operator>>(istream& in, string& s)
	{
		s.clear();
		char ch;
		ch = in.get();/每次获取一个字符
		while (ch != ' ' && ch != 'n')
		{
			s += ch;
			ch = in.get();
		}

		return in;
	}
输出
	ostream& operator<<(ostream& out, const string& s)
	{
		/ 不管字符数组中的内容是啥，size是多少，就要输出多少个有效字符
		for (size_t i = 0; i < s.size(); ++i)
		{
			out << s[i];
		}

		return out;
	}