C++STL - string类的模拟实现

默认成员函数

构造函数

把构造函数设置为缺省参数，当不传入参数时，默认构造为空字符串。字符串的初始大小和容量均设置为传入字符串的长度（不包括'\0'）

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

拷贝构造函数

我们先了解深浅拷贝：

浅拷贝：拷贝出来的目标对象的指针和源对象的指针指向的内存空间是同一块空间。其中一个对象的改动会对另一个对象造成影响。

深拷贝：深拷贝是指源对象与拷贝对象互相独立。其中任何一个对象的改动不会对另外一个对象造成影响。

我们并不希望拷贝出来的两个对象之间存在相互影响，因此，我们这里需要用到深拷贝。

方法一

先开辟一块足以容纳源对象字符串的空间，然后将源对象的字符串拷贝过去，接着把源对象的其他成员变量也赋值过去即可。因为拷贝对象的str与源对象的str指向的并不是同一块空间，所以拷贝出来的对象与源对象是互相独立的。

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

方法二

方法二很简单，先根据源字符串的C字符串调用构造函数构造一个tmp对象，然后再将tmp对象与拷贝对象的数据交换即可。拷贝对象的str与源对象的str指向的也不是同一块空间，是互相独立的

string(const string& str) 
	:_str(nullptr)
	,_size(0)
	,_capacity(0)
{
	string tmp(str._str);
	swap(tmp);
}
void swap(string& s) {
	std::swap(s._str, _str);
	std::swap(s._size, _size);
	std::swap(s._capacity, _capacity);
}

赋值运算符重载函数

与拷贝构造函数类似，赋值运算符重载函数的模拟实现也涉及深浅拷贝问题，我们同样需要采用深拷贝。

方法一

赋值运算符重载函数写法与拷贝构造函数写法几乎相同，只是左值的_str在开辟新空间之前需要先将原来的空间释放掉，否则会发生内存泄漏

string& operator=(const string& str) {
	if (this == &str) {
		return *this;
	}
	delete[] _str;
	_str = new char[str._capacity+1];
	_capacity = str._capacity;
	_size = str._size;
	strcpy(_str, str._str);
	return *this;	
}

方法二

采用"值传递"接收右值的方法，让编译器自动调用拷贝构造函数，然后我们再将拷贝出来的对象与左值进行交换即可。

string& operator=(string tmp) {
	swap(tmp);
	return *this;
}

析构函数

string类的析构函数需要我们进行编写，因为每个string对象中的成员_str都指向堆区的一块空间，当对象销毁时堆区对应的空间并不会自动销毁，为了避免内存泄漏，我们需要使用delete手动释放堆区的空间。

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

迭代器相关函数

string类中的迭代器实际上就是字符指针，只是把它typedef成了iterator。

typedef char* iterator;

typedef const char* const_iterator;

begin和end

string类中的begin和end函数的实现很简单，就是返回字符串的首尾地址

iterator begin() {
	return _str;
}
iterator end() {
	return _str + _size;
}
const_iterator begin() const{
	return _str;
}
const_iterator end() const{
	return _str + _size;
}

所以我们用迭代器遍历string时，其实就是用指针在遍历字符串而已。

再说范围for，代码编译的时候，编译器会自动将范围for替换为迭代器的形式，也就是说范围for是由迭代器支持的。

string s("hello world");

for (auto& e : s)
{
	cout << e << " ";
}
cout << endl;

容量和大小相关函数

size和capacity

string类的成员变量是私有的，我们并不能直接对其进行访问，所以string类设置了size和capacity这两个成员函数，用于获取string对象的大小和容量。

size用于获取字符串当前的长度，capacity用于获取字符串当前的容量。

size_t size() const{
	return _size;
}
size_t capacity() const {
	return _capacity;
}

reserve和resize

reserve

当n大于对象当前的capacity时，将capacity扩大到n或大于n。

当n小于对象当前的capacity时，什么也不做。

void reserve(size_t n) {
	if (n > _capacity) {
		char* tmp = new char[n+1];
		strcpy(tmp, _str);
		delete[] _str;
		_str = tmp;
		_capacity = n;
	}
}

resize

当n大于当前的size时，将size扩大到n，扩大的字符为ch，若ch未给出，则默认为'\0'。

当n小于当前的size时，将size缩小到n。

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

empty

bool empty(){
	return _size == 0;
}

修改字符串相关函数

push_back

push_back函数的作用就是在当前字符串的后面尾插上一个字符，尾插之前首先需要判断是否需要增容，若需要，则调用reserve函数进行增容，然后再尾插字符，注意尾插完字符后需要在该字符的后方设置上'\0'，否则打印字符串的时候会出现非法访问，因为尾插的字符后方不一定就是'\0'。

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

append

append函数的作用是在当前字符串的后面尾插一个字符串，尾插前需要判断当前字符串的空间能否容纳下尾插后的字符串，若不能，则需要先进行增容，然后再将待尾插的字符串尾插到对象的后方，因为待尾插的字符串后方自身带有'\0'，所以我们无需再在后方设置'\0'。

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

operator+=

+=运算符的重载是为了实现字符串与字符、字符串与字符串之间能够直接使用+=运算符进行尾插。

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

insert

insert函数的作用是在字符串的任意位置插入字符或是字符串。

insert函数用于插入字符时，首先需要判断pos的合法性，若不合法则无法进行操作，紧接着还需判断当前对象能否容纳插入字符后的字符串，若不能则还需调用reserve函数进行扩容。插入字符的过程也是比较简单的，先将pos位置及其后面的字符统一向后挪动一位，给待插入的字符留出位置，然后将字符插入字符串即可。

string& insert(size_t pos, char ch) {
	assert(pos <= _size);
	if (_size == _capacity) {
		_size == 0 ? reserve(4) : reserve(_capacity * 2);
	}
	for (size_t i = _size + 1; i > pos; i--) {
		_str[i] = _str[i - 1];
	}
	_str[pos] = ch;
	_size++;
    return *this
}

insert函数用于插入字符串时，首先也是判断pos的合法性，若不合法则无法进行操作，再判断当前对象能否容纳插入该字符串后的字符串，若不能则还需调用reserve函数进行扩容。插入字符串时，先将pos位置及其后面的字符统一向后挪动len位（len为待插入字符串的长度），给待插入的字符串留出位置，然后将其插入字符串即可。

string& insert(size_t pos, const char* str) {
	assert(pos <= _size);
	size_t len = strlen(str);
	if (len + _size >= _capacity) {
		reserve(len + _size + 1);
	}
	for (size_t i = _size + len; i > pos + len - 1; i--) {
		_str[i] = _str[i - len];
	}
	strncpy(_str + pos, str, len);
	_size += len;
	_str[_size] = '\0';
    return *this
}

erase

erase函数的作用是删除字符串任意位置开始的n个字符，这时就分为两种情况。

pos位置及其之后的有效字符都需要被删除。

这时我们只需在pos位置放上'\0'，然后将对象的size更新即可。

pos位置及其之后的有效字符只需删除一部分。

这时我们可以用后方需要保留的字符覆盖前方需要删除的有效字符。

string& erase(size_t pos, size_t len = npos) {
	assert(pos < _size);
	if (len == npos || len + pos > _size) {
		_size = pos;
		_str[pos] = '\0';
	}
	else {
		size_t begin = pos + len;
		while (begin <= _size) {
			_str[begin - len] = _str[begin];
			++begin;
		}
		_size -= len;
	}
    return *this
}

clear

clear函数用于将对象中存储的字符串置空，实现时直接将对象的_size置空，然后在字符串后面放上'\0'即可。

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

swap

swap函数用于交换两个对象的数据，直接调用库里的swap模板函数将对象的各个成员变量进行交换即可。

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

c_str

c_str函数用于获取对象C类型的字符串，实现时直接返回对象的成员变量_str即可。

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

访问字符串相关函数

operator

运算符的重载是为了让string对象能像C字符串一样，通过 +下标的方式获取字符串对应位置的字符。

在C字符串中我们通过 +下标的方式可以获取字符串对应位置的字符，并可以对其进行修改，实现 运算符的重载时只需返回对象C字符串对应位置字符的引用即可，这样便能实现对该位置的字符进行读取和修改操作了，但需要注意在此之前检测所给下标的合法性。

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

find

find函数和rfind函数都是用于在字符串中查找一个字符或是字符串，find函数和rfind函数分别用于正向查找和反向查找，即从字符串开头开始向后查找和从字符串末尾开始向前查找。

find函数：

1、正向查找第一个匹配的字符。

首先判断所给pos的合法性，然后通过遍历的方式从pos位置开始向后寻找目标字符，若找到，则返回其下标；若没有找到，则返回npos。（npos是string类的一个静态成员变量，其值为整型最大值）

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

2、正向查找第一个匹配的字符串。

首先也是先判断所给pos的合法性，然后我们可以通过调用strstr函数进行查找。strstr函数若是找到了目标字符串会返回字符串的起始位置，若是没有找到会返回一个空指针。若是找到了目标字符串，我们可以通过计算目标字符串的起始位置和对象C字符串的起始位置的差值，进而得到目标字符串起始位置的下标

size_t find(const char* str, size_t pos = 0) {
	char* p = strstr(_str + pos, str);
	if (p) {
		return p - _str;
	}
	else {
		return npos;
	}
}

关系运算符重载函数

关系运算符有 >、>=、<、<=、==、!= 这六个，但是对于C++中任意一个类的关系运算符重载，我们均只需重载其中的两个，剩下的四个关系运算符可以通过复用已经重载好了的两个关系运算符来实现。

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

剩下的四个关系运算符的重载，直接复用即可

bool operator<(const string& s) const {
	return strcmp(_str, s._str) < 0;
}
bool operator<=(const string& s) const {
	return !(*this > s);
}
bool operator>=(const string& s) const {
	return !(*this < s);
}
bool operator!=(const string& s) const {
	

>>和<<运算符的重载

>>运算符的重载

重载>>运算符是为了让string对象能够像内置类型一样使用>>运算符直接输入。输入前我们需要先将对象的C字符串置空，然后从标准输入流读取字符，直到读取到' '或是'\n'便停止读取。这里还进行了优化添加了buff缓冲区分批读取，减少扩容

istream& operator>>(istream& in, string& s) {
	s.clear();
	char ch;
	char buff[129];
	size_t i = 0;
	ch = in.get();
	while (ch != ' ' && ch != '\n') {
		buff[i++] = ch;
		if (i == 128) {
			buff[i] = '\0';
			s += buff;
			i = 0;
		}
			
		ch = in.get();
	}

	if (i != 0) {
		buff[i] = '\0';
		s += buff;
	}
	return in;
}

<<运算符的重载

重载<<运算符是为了让string对象能够像内置类型一样使用<<运算符直接输出打印。

ostream& operator<<(ostream& out, const string& s) {
	out << s.c_str();
	return out;
}