成员变量和查看接口

  string类中有三个成员变量分别记录有效元素个数、容量和字符串。而静态变量npos=1表示整型的最大值，且只能在类外部进行赋值

成员变量：

private:
	size_t _size;	//个数
	size_t _capacity; //容量
	char* _str;		//字符数组
public:
	const static size_t npos; //表示整形最大值

迭代器（读和读写）

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;
}

operator[]（读和读写）

  const成员函数前面的返回值也必须加上const，this->_str 不能被修改，而指针是内置类型，指针不能被修改，但是指针指向区域内容却可以被修改，因此返回值前面加上 const

char& operator[](size_t pos) 
{
    
    
	assert(pos < _size);
	return _str[pos]; 
}
const char& operator[](size_t pos)const
{
    
    
	assert(pos < _size);
	return _str[pos];
}

c_str()

const char* c_str() const
{
    
    
	return _str;
}

size()

size_t size() const
{
    
    
	return _size;
}

构造函数

用字符串构造

  注意，无参时我们给缺省值，给空串，里面不能带 空格，空格也是有效字符。new 开空间的时候，要开字符串长度 +1个，strlen() 函数只会记录有效字符个数，我们需要多卡一个空间给 \0 字符

string(const char* str = "")
{
    
    
	_size = strlen(str);
	_capacity = _size;
	_str = new char[_capacity + 1];
	memcpy(_str, str, _size + 1);
}	

用对象构造（两种方法）

  方法 1 用 memcpy 库函数，而不是 strcpy ，对于 “abc \0 def” 这种字符串，strcpy没办法处理，遇到 \0 就终止了，而 memcpy 是按内存中字节拷贝的
  方法 2 的话，调用了 swap() 库函数，且复用了用字符串构造函数，这里还需注意必须初始化 _str ，它是指针类型的，编译器不会自动初始化，那么和 tmp 交换后，析构 tmp 就会析构一段非法空间，而报错

//方法 1
string(const string& s)
{
    
    
	_str = new char[s._capacity + 1];
	memcpy(_str, s._str, s._size + 1);
	_size = s._size;
	_capacity = s._capacity;
}
//方法 2
string(const string& s)
	:_size(0)
	,_capacity(0)
	,_str(nullptr)
{
    
    
	string tmp(s._str);
	swap(tmp);
}

析构

~string()
{
    
    
	delete[] _str;
	_str = nullptr;
	_size = _capacity = 0;
}

赋值运算符重载

  方法一比较原始，实现方法和 reserve() 函数一样，先开一样大小的空间，然后拷贝数据，再销毁原来空间，更新 _str，_capacity，_size
  方法二调用库里面的 swap() 函数便能轻松解决，那么思考为什么我们不直接交换 swap(*this, tmp) ？先看库里面 swap() 函数实现，不难发现里面的对象交换需要相互赋值，而赋值又要调用 operator()，而 operator() 里面又会调用 swap() 依次进行就变成了死递归

//方法一
string& operator=(const string& s)
{
    
    
	if (this != &s)
	{
    
    
		char* tmp = new char[s._capacity + 1];
		memcpy(tmp, s._str, s._size+1);
		delete[] _str;
		_str = tmp;
		_size = s._size;
		_capacity = s._capacity;
	}
	return *this;
}
//方法二
string& operator=(string tmp)
{
    
    
    //std::swap(*this,tmp);//这样写死递归
	std::swap(_str, tmp._str);
	std::swap(_size, tmp._size);
	std::swap(_capacity, tmp._capacity);
	return *this;
}

扩容和调整

  扩容我们采取异地扩容的方式，考虑到 reserve() 函数外部也可以用，因此加个判断，异地扩容后记得把原来空间释放掉

reserve()

void reserve(size_t n)
{
    
    	
	//异地扩容
	if (n > _capacity)
	{
    
    
		char* tmp = new char[n + 1];
		memcpy(tmp, _str, _size + 1);
		delete[] _str;
		_str = tmp;
		_capacity = n;
	}
}

resize()

  空间变小的话，我们还是不改变 _capacity，把 _size 改了，再赋上 \0 就行，空间大了的话，我们就异地扩容，再给要改变的 ch 加上缺省值 \0

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

clear()

void clear()
{
    
    
	_size = 0;
	_str[_size] = '\0';
}

增删查改

push_back()

	void push_back(const char ch)
	{
    
    
		//扩容×2
		if (_size == _capacity)
		{
    
    
			//有可能用空串初始化的
			reserve(_capacity == 0 ? 4 : _capacity * 2);
		}
		_str[_size] = ch;
		++_size;
		_str[_size] = '\0';
	}

append()

	void append(const char* str)
	{
    
    
		size_t len = strlen(str);
		if (_size + len > _capacity)
		{
    
    
			reserve(_size + len);
		}
		//strcpy(_str + _size, str);
		memcpy(_str + _size, str, len + 1);
		_size += len;
	}

operator+=()

  直接复用前面两个函数 push_back() 和 append() ，调用这两个函数，再考虑空间够不够，不够就扩容再尾插

	string& operator+=(const char ch)
	{
    
    
		push_back(ch);
		return *this;
	}
	string& operator+=(const char* str)
	{
    
    
		append(str);
		return *this;
	}

insert()（字符和字符串）

  首先，检查一下插入位置的合法性，然后这意一下，end 是无符号类型，考虑 pos为0 时会造成死循环，end减为 -1 却是整形最大值，因此我们前面设置的静态变量 npos 便发挥了作用。最后注意边界问题，是否需要扩容

	void insert(size_t  pos, size_t n, char ch)
	{
    
    
		assert(pos <= _size);
		if (_size + n > _capacity)
		{
    
    
			reserve(_size + n);
		}

		size_t end = _size;
		_size += n;
		//end是无符号类型，考虑pos为0时 的死循环
		while (end >= pos && end != npos)
		{
    
    
			_str[end + n] = _str[end];
			end--;
		}
		for (size_t i = 0; i < n; i++)
		{
    
    
			_str[pos + i] = ch;
		}
	}
	void insert(size_t pos, const char* str)
	{
    
    
		assert(pos <= _size);
		size_t len = strlen(str);
		if (len + _size > _capacity)
		{
    
    
			reserve(len + _size);
		}
		size_t end = _size;
		_size += len;
		while (end >= pos && end != npos)
		{
    
    
			_str[end + len] = _str[end];
			end--;
		}
		for (size_t i = 0; i < len; i++)
		{
    
    
			_str[pos + i] = str[i];
		}
	}

erase()

  删除字符的个数我们给缺省值，方便边界判断。考虑 pos 的合法性后，再处理边界问题，删除工作就是不断从后往前迭代

void erase(size_t pos, size_t len = npos)
{
    
    
	assert(pos <= _size);
	if (len == npos || pos + len >= _size){
    
    
		_str[pos] = '\0';
		_size = pos;
	}
	else {
    
    
		size_t end = pos + len;
		while (end <= _size)
		{
    
    
			_str[end-len] = _str[end];
			++end;
		}
		_size -= len;
	}
}

find() （字符和字符串）

  没有找到找到就返回 npos ，缺省值从 0 开始找，找字符串有很多中算法，KMP，BF … 这里我们直接调用 strstr() 库函数简单实现就行

size_t find(char ch, size_t pos = 0)
{
    
    
	assert(pos < _size);
	for (size_t i = pos; i < _size; i++)
	{
    
    
		if (_str[i] == ch)
		{
    
    
			return i;
		}
	}
	return npos;
}
size_t find(const char* str, size_t pos = 0)
{
    
    
	assert(pos < _size);
	const char* ptr = strstr(_str + pos, str);
	if (ptr){
    
    
		return ptr - _str;
	}
	else {
    
    
		return npos;
	}
}

substr()

  检查 pos 合法性后，我需要计算切割字符串的长度。注意我们返回的是一个临时的 string 类，开好空间，然后调用 operator+= 函数，它会自动处理后面的 \0

string substr(size_t pos=0, size_t len = npos)
{
    
    
	assert(pos < _size);
	size_t n = len;
	if (len == npos || pos + len >= _size)
	{
    
    
		n = _size - pos;
	}
	string tmp;
	tmp.reserve(n);
	for (size_t i = pos; i < pos + n; i++)
	{
    
    
		tmp += _str[i];
	}
	return tmp;
}

string大小比较

operator<()

  由于字符串比较情况种类较多，比如 “abc” “abcd” 这种情况， 库函数 strcmp，memcmp 便不再适用， 它们适用于相同长度的字符串比较，长度不同容易出现越界问题，这里我们直接自己实现

bool operator<(const string& s) const
{
    
    
	size_t lt1 = 0;
	size_t lt2 = 0;
	while (lt1 < _size && lt2 < s._size)
	{
    
    
		if (_str[lt1] < s._str[lt2]) {
    
    
			return true;
		}
		else if (_str[lt1] > s._str[lt2]) {
    
    
			return false;
		}
		else {
    
    
			lt1++;
			lt2++;
		}
	}
	return _size < s._size;
}

operator==()

bool operator==(const string& s) const
{
    
    
	return _size == s._size && memcmp(_str, s._str, _size) == 0;
}

复用

bool operator<=(const string& s) const
{
    
    
	return *this < s || *this == s;
}
bool operator>(const string& s) const
{
    
    
	return !(*this <= s);
}
bool operator>=(const string& s) const
{
    
    
	return *this > s || *this == s;
}
bool operator!=(const string& s) const
{
    
    
	return !(*this == s);
}

IO流

operator<<()

ostream& operator<<(ostream& out, const string& s)
{
    
    
	for (auto ch : s)
	{
    
    
		out << ch;
	}
	return out;
}

operator>>()

  插入前要处理，缓冲区前面的空格和换行，用循环解决掉空格和换行字符。进行流插入的时候，我们设置一个中将数组，让插入数据先放在buff数组中，避免调用多次 operator+= 函数而引起多次扩容判断，最后再处理后面的 \0

istream& operator>>(istream& in, string& s)
{
    
    
	s.clear();
	char ch = in.get();
	//除去缓冲区的空格和换行
	while (ch == ' ' || ch == '\n')
	{
    
    
		ch = in.get();
	}
	//用一个中将容器，减少扩容次数
	char buff[128];
	size_t i = 0;
	while (ch != ' ' && ch != '\n')
	{
    
    
		buff[i++] = ch;
		if (i == 127)
		{
    
    
			//加上'\0'以免+=出问题
			buff[i] = '\0';
			s += buff;
			i = 0;
		}
		ch = in.get();
	}
	if (i != 0)
	{
    
    
		buff[i] = '\0';
		s += buff;
	}
	return in;
}