string类的实现

        在C++的string库中，有许多关于string类的成员函数，极大方便了我们进行相关的操作，在这里我们尝试将string类中冗余的接口去掉，实现自己的string类。

（1）命名空间

        首先创建资格命名空间，避免自己的string类和编译器产生冲突，同时定义好自己的类。

namespace chm
{
    class string
    {
    public:
        //……
    private:
        char* _str = nullptr//存储字符串
        size_t _size = 0//元素个数
        size_t _capacity = 0//容量
    };
}

（2）构造函数和析构函数

        定义好自己的string类之后，我们实现string类的构造函数和析构函数，构造函数我们需要实现全缺省构造函数和拷贝构造函数。

string(const char* str = "")//常量字符串后会加\0，即使啥都没有也会加上\0
{
	_size = strlen(str);
	//_capacity不包含\0
	_capacity = _size;
	_str = new char[_size + 1];
	strcpy(_str, str);//先拷贝后判断，会把\0也传过去
}

string(const string& s)//传统拷贝，自己去调用空间进行拷贝
{
	_str = new char[s._capacity + 1];//注意深浅拷贝问题，不能简单赋值
	strcpy(_str, s._str);
	_size = s._size;
	_capacity = s._capacity;
}

         除了传统的拷贝构造函数，我们也可以使用新的方式去写

void swap(string& tmp)
{
	std::swap(_str, tmp._str);
	std::swap(_size, tmp._size);
	std::swap(_capacity, tmp._capacity);
}

string(const string& s)//新方法，不自己动手申请空间
{
	string tmp(s._str);
	swap(tmp);
}

        在这个方法中，我们的tmp与*this进行交换，_str所指向的地址，_capacity,_size的值全都被交换，同时tmp出了作用域自动进行销毁，无需其他操作。

~string()//析构函数
{
	delete[] _str;
	_str = NULL;
	_capacity = _size = 0;
}

（3）迭代器进行遍历

        在string类中，我们可以利用迭代器和范围for进行string的遍历，而这个迭代器的作用，其实类似于指针，所以我们自己实现的迭代器中，可以将char*重命名为迭代器

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

（4）返回指针和元素个数

const char* c_str()
{
	return _str;
}

size_t size() const
{
	return _size;
}

（5）[]运算符重载

        在观察库里string类对[]运算符的重载，会发现是返回改对象的引用从而进行修改

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

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

（6）push_back（）尾插和append()附加

        push_back和append两个函数一个在后面加字符，另一个加字符串，思路都是先检查容量够不够，由此引入reserve（）函数——预留空间。

void string::reserve(int n)
{
	if (n > _capacity)
	{
		char* tmp = new char[n + 1];//为\0预留空间
		strcpy(tmp, _str);
		delete[] _str;//释放旧空间
		_str = tmp;
		_capacity = n;
	}
}

void string::push_back(char x)
{
	if (_size == _capacity)
	{
		reserve(_capacity == 0 ? 4 : 2 * _capacity);
	}
	_str[_size] = x;
	_size++;
	_str[_size] = '\0';//注意\0的尾插
}

void string::append(const char* str)
{
	size_t len = strlen(str);
	if (_size + len > _capacity)
	{
		reserve(_size + len > 2 * _capacity ? _size + len : 2 * _capacity);
	}
	strcpy(_str + _size, str);
	_size += len;
}

（7）+=运算符重载

        在实现了push_back和append函数后，重载+=运算符就比较简单了

string& string::operator+=(char x)
{
	push_back(x);
	return *this;
}

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

（8）insert（）插入函数

        insert插入函数分为插入字符和字符串两种，其中第一步都是先确认空间，第二步为挪动数据，最后为插入新数据

        

void string::insert(size_t pos, char x)
{
	assert(pos < _size);
	if (_size == _capacity)
	{
		reserve(_capacity == 0 ? 4 : 2 * _capacity);
	}
	//int n = _size;
	//while (n >= (int)pos)//两个不同类型的参数进行比较时会发生类型转换，由int变为size_t(无符号类型)，n就不可能为负数，当pos为0时(也就是头插)，无法结束程序
	//{
	//	_str[n + 1] = _str[n];
	//	n--;
	//}
	//_str[pos] = x;
	//_size++;
	size_t end = _size + 1;
	while (end > pos)//解决0的问题
	{
		_str[end] = _str[end - 1];
		end--;
	}
	_str[pos] = x;
	_size++;
}

void string::insert(size_t pos, const char* str)
{
	assert(pos < _size);
	size_t len = strlen(str);
	if (len == 0)
		return;
	if (_size + len > _capacity)
	{
		reserve(_size + len > 2 * _capacity ? _size + len : 2 * _capacity);
	}
	size_t end = _size + len;
	while (end > pos - 1 + len)
	{
		_str[end] = _str[end - len];
		end--;
	}
	for (int i = 0; i < len; i++)
	{
		_str[pos + i] = str[i];
	}
	_size += len;
}

（9）substr（）获取子串

        利用substr函数获取对应位置的子串

string string::substr(size_t pos, int len)
{
	assert(pos < _size);
	if (len > _size - pos)
	{
		len = _size - pos;
	}

	string sub;
	sub.reserve(len);

	for (size_t i = 0; i < len; i++)
	{
		sub += _str[ pos + i];
	}
	return sub;
}

（10）erase（）擦除函数

void string::erase(size_t pos, int len)
{
	assert(pos < _size);
	if (len > _size - pos)
	{
		_str[pos] = '\0';
		_size = pos;
	}
	else
	{
		for (int i = pos + len; i <= _size; i++)
		{
			_str[i - len] = _str[i];
		}
		_size -= len;
	}
}

（11）find（）查找函数

size_t string::find(char x, size_t pos)
{
	for (int i = pos; i < _size; i++)
	{
		if (_str[i] == x)
			return i;
	}
	return npos;
}

size_t string::find(const char* str, size_t pos)
{
	assert(pos < _size);
	const char* find = strstr(_str, str);
	if (find != nullptr)
	{
		return find - _str;
	}
	else
	{
		return npos;
	}
}

  （12）流插入流提取重载

        需要注意的是，这两个函数需要重载成全局函数

        

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

	istream& operator>>(istream& in, string& s)
	{
		s.clear();
		char ch;
		in.get(ch);//不直接用in>>ch的原因是in默认将输入时的空格看为分割符，直接忽略，ch!=' '条件 
                   //不起作用
		while (ch != ' ' && ch != '\n')
		{
			s += ch;
			in.get(ch);
		}
		return in;
	}