构造函数

无参数构造和传参构造

通过对参数设置缺省值为空串""同时满足无参构造和传参构造
成员 _size 和 _capacity 均是针对有效位的
开辟空间时除有效位外，要多预留一字节空间给 ‘\0’

string(const char* str = "")
	:_size(strlen(str))
{
	//注意size和capacity均是针对有效位的，
	//但是有效位占空间时要多预留一位给'\0'
	//多的一位只通过开空间时进行预留
	_capacity = _size == 0 ? 4 : _size;
	_str = new char[_capacity + 1];
	strcpy(_str, str);
}

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

赋值重载

关于浅拷贝

若不主动显示赋值重载，会导致浅拷贝问题

两对象的 _str 相同，都指向同一块空间，改变其中一个对象内容会相互影响
两对象生命周期结束时，都会调用析构函数，对同一空间析构两次
若对本身赋值，直接返回本身
开辟临时空间拷贝内容，避免new失败破坏原数据
将原空间释放，同时 _str 指向拷贝好的临时空间

//赋值运算符重载
string& operator=(string& s)
{
	if (this != &s)
	{
		//_str的空间不一定为空，所以要用临时空间拷贝s._str的内容
		//再释放_str的原空间，同时_str指向开好的临时空间
		char* tmp = new char[s._capacity + 1];
		strcpy(tmp, s._str);
		delete[] _str;
		_str = tmp;

		_size = s._size;
		_capacity = s._capacity;
	}
	return *this;
}

迭代器

迭代器是类里内嵌的 typedef ，区分普通迭代器和 const 迭代器(标准库还有反向迭代器)
typedef char* iterator;
typedef const char* const_iterator;

遍历可使用下标遍历、迭代器遍历、范围for
范围for 本质上是迭代器，会自动识别普通迭代器和const迭代器

iterator begin() const
{
	return _str;
}
iterator end() const
{
	return _str + size();
}
//使用迭代器遍历
string::iterator it = s2.begin();
while (it != s2.end())
{
	cout << (*it) << " ";
	++it;
}
cout << endl;

容量相关

容量相关函数不会轻易缩容！！

reserve

更改容量

void reserve(size_t n)
{
	if (n > _capacity)
	{
		char* tmp = new char[n + 1];
		strcpy(tmp, _str);
		//拷贝后将原空间释放
		//cout << typeid(_str).name << endl;
		delete[] _str;
		_str = tmp;

		_capacity = n;
	}
}

resize

若参数 n 小于 _size ，再 n 位置设置 ‘\0’ ，改变 _size 为 n，实现缩短串的长度
若参数 n 大于 _size 小于 _capacity，将剩余空间设置为参数字符
若参数 n 大于 _capacity，reserve扩容再设置字符

//resize
void resize(size_t n, char ch)
{
	if (n <= _size)
	{
		_str[n] = '\0';
		_size = n;
	}
	else
	{
		if (n > _capacity)
			reserve(n);
		size_t i = _size;
		while (i < n)
		{
			_str[i] = ch;
			++i;
		}
		_size = n;
		_str[_size] = '\0';
	}
}

修改

push_back

尾部插入字符
无多余空间则进行扩容

void push_back(const char ch)
{
	if (_size == _capacity)
	{
		reserve(_capacity * 2);
	}
	_str[size()] = ch;
	++_size;
	_str[size()] = '\0';
}

append

尾部插入字符串
同样空间不够先扩容
关于用strcpy而不用strcat：
strcat 追加内容前会先查找 ‘\0’ 的位置，会降低效率，使用strcpy可直接指定拷贝位置

void append(const char* str)
{
	size_t len = strlen(str);
	if (_size + len > _capacity)
	{
		reserve(_size + len);
	}
	//这里如果用strcat进行追加，
	//strcat会先查找'\0'的位置，会降低效率
	//所以这里使用strcpy直接指定拷贝位置
	strcpy(_str + _size, str);
}

insert

挪动数据时，应考虑0位置插入特殊情况
区分插入字符与插入串进行重载

//insert区分字符与串进行重载
void insert(size_t pos, char ch)
{
	assert(pos <= _size);
	if (_size + 1 > _capacity)
	{
		reserve(_capacity + 1);
	}
	size_t end = _size + 1;
	//注意控制结束条件
	//考虑0位置插入情况
	while (end > pos)
	{
		_str[end] = _str[end - 1];
		--end;
	}
	_str[pos] = ch;
	++_size;
}
void insert(size_t pos, const char* str)
{
	assert(pos <= _size);
	size_t len = strlen(str);
	if (_size + len > _capacity)
	{
		reserve(_size + len);
	}
	size_t end = _size + len;
	//注意各条件的控制
	while (end > pos + len - 1)
	{
		_str[end] = _str[end - len];
		--end;
	}
	strncpy(_str + pos, str, len);
	_size += len;
}

erase

关于npos

string::npos是一个静态成员常量，表示size_t的最大值（Maximum value for size_t）。该值表示“直到字符串结尾”，作为返回值它通常被用作表明没有匹配。
static const size_type npos = -1;

erase 函数参数为开始删除位置、删除长度

void erase(size_t pos, size_t len = npos)
{
	assert(pos < _size);
	if (len != npos && len < _size - pos)
	{
		strcpy(_str + pos, _str + pos + len);
		_size -= len;
	}
	else
	{
		_str[pos] = '\0';
		_size = pos;
	}
}

流运算符重载

流插入

//注意使用const和引用
ostream& operator<<(ostream& out, const string& s)
{
	for (auto e : s)
	{
		out << e;
	}
	return out;
}

流提取

对于 ' '和'\n'----
C++认为是多个字符间的间隔，cin 和 scanf 提取时会忽略
为了能将' '和'\n'提取到缓冲区以便条件判断，使用get函数接收输入内容
操作前先将原串 clear ----
若不clear，对于"hello\0xxx\0"这样的串，扩容时的strcpy会以第一个'\0'结束，会造成不可预见的后果
考虑插入内容较长：
用一个buffer 串接受插入内容，buffer每满一次拷贝一次到待插入对象
这样就减少了扩容次数

istream& operator>>(istream& in, string& s)
{
	s.clear();
	//get会将' '和'\n'都提取进缓冲区，方可进行while循环判断
	char ch = in.get();
	//char buffe	r[10];
	char buffer[128];

	size_t i = 0;
	while (ch != ' ' && ch != '\n')
	{
		buffer[i++] = ch;
		if (i == 127)
		{
			//！！注意设置'\0'
			buffer[i] = '\0';
			s += buffer;
			i = 0;
		}
		ch = in.get();
	}
	if (i != 0)
	{
		//！！注意设置'\0'
		buffer[i] = '\0';
		s += buffer;
	}
	return in;
}