【C++数据结构】string的模拟实现

为了更好的使用C++中的标准库，下面是对string一些比较重要的接口进行模拟实现，有需要借鉴即可。

这里给出string文档地址链接，方便对照：LINK

1.string结构的设计

string底层我们使用字符数组来实现，即顺序表，惟一与顺序表做区分的是我们的string后面默认有个\0，这个需要注意的。

class string
{
   
   
private:
	char* _str;
	size_t _size;
	size_t _capacity;
};

2.string构造函数

string构造函数的模拟实现有两种实现方式，

• 1.分开写无参构造函数和有参构造函数
• 2.只写一个通用的构造函数，即全缺省构造函数

下面来介绍两种不同的写法：

2.1构造函数分开写

//分开写的情况下：
//无参构造器
string()
	:_str(new char)//这里写nullptr可以吗？不可以，因为这样用于结合c_str的接口特性。
	, _size(0)
	, _capacity(0)
{
   
   
	_str[0] = '\0';
}

//有参构造器
string(const char* str)
	:_size(strlen(str))
{
   
   
	_capacity = _size;//capacity和size计算给值
	_str = new char[_size + 1];//给空间
	strcpy(_str, str);//拷贝过去，这里自带\0不用担心
}
*/

思考：开空间时候为什么多开一个？
答：为\0预留位置。在上面无参构造器种开一个空间即是这个道理

思考：为什么要在string末尾多加一个\0？
我们说，C语言喜欢把字符串末尾多加一个\0，这是因为C语言没有标识字符串的长度，用\0来标识字符的结尾。但是我们string是有_size来进行维护的呀，怎么还需要用\0呢？
答：其实这个问题是string要与C字符串相兼容的缘故，正因为是C++要兼容C也是一样的道理。

2.2构造函数一块写

string(const char* str = "")//这个地方的缺省参数用什么？
	:_size(strlen(str))//看一下有一个字符
{
   
   
	_capacity = _size;//标识该字符的长度，空间大小，标识情况下并不包含capacity的大小
	_str = new char[_capacity + 1];//开空间
	strcpy(_str, str);//把临时变量的值拷贝过去
}

思考：str为什么给缺省值？
答：因为这主要是有时候是充当无参构造器来用的。
思考：这个str的缺省值为什么给两个引号？
答：这里并不是两个引号的意思，而是一个字符串，这个字符串是有一个字符的，为\0。

拷贝构造函数怎么写？这个地方涉及到深浅拷贝问题，所以需要自己另开空间才行

2.3拷贝构造函数的传统写法

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

2.4拷贝构造函数的现代写法

//现代写法
string(string& s)
{
   
   
	string temp(s._str);//这个地方会去调用构造函数，构造出一个新的堆过来。
	swap(temp);
}

思考：拷贝构造函数的传统写法和现代写法哪个更好？
答：他俩是基本一样的，只不过第二种把第一种那一段代码用构造函数等效掉了。

2.5赋值运算符重载

string& operator=(const string& s)
{
   
   
	_capacity = s._capacity;
	_size = s._size;

	delete[] _str;
	char* temp = new char[_capacity + 1];
	_str = temp;
	strcpy(_str, s._str);

	return *this;
}

思考：什么时候编译器会调用赋值运算符重载，又什么时候调用拷贝构造函数呢？
答：切忌不能单看是不是写的等于号哈，如果string s已存在，string sc正在创建，那调用的就是拷贝构造，如果s和sc都已经存在了，那就是调用的是赋值运算符重载。

其实赋值运算符重载也有现代写法，说白了算是一种复用吧：

//传统写法
/*
string& operator=(const string& s)
{
	_capacity = s._capacity;
	_size = s._size;

	delete[] _str;
	char* temp = new char[_capacity + 1];
	_str = temp;
	strcpy(_str, s._str);

	return *this;
}
*/

/*
//现代写法
string& operator=(const string& s)
{
	string temp(s.c_str());
	swap(temp);

	return *this;
}
*/
//极简版
string& operator=(string temp)
{
   
   
	swap(temp);

	return *this;
}

说完了构造函数的实现，我们再来说一下析构函数的写法

3.析构函数

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

析构函数这里很简单，不再多说。

4.遍历

遍历是string种常用的功能之一。string的遍历方式主要有三种，其一曰方括号，其二曰迭代器，其三曰范围for；

下面依次介绍三种string遍历的模拟实现：

4.1operator[]重载

char& operator[](size_t pos)
{
   
   
	assert(pos < _size);//越界检查,传统的C语言数组检查是一种抽查

	return _str[pos];
}

检查方式的进步：
注：这里需要注意一点的是方括号的函数重载的越界检查，这个越界检查是用assert实现的，更加全面安全；相对于C语言来说，因为C语言的越界检查是一种“抽查”，有时候读越界的时候是检查不出来的。

思考：这里返回值为什么用char&
答：效率更加高效，第二就是更加方便对string字符值的修改。因为遍历支持可读可写。

当然，为了适应不可修改的const string，我们也提供了const []重载

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

这个函数后面为什么加const呢？
答：
1.防止在函数内对string字符做修改
2.构成函数重载
3.便于编译器调用const或非const的函数匹配

4.2迭代器

string的迭代器是一种像指针的遍历方式，使用上很像指针，但是具体内部是不是指针这就看具体是怎么实现的了。

typedef char* iterator;//必须要统一名称 + 类域

iterator begin()
{
   
   
	return _str;
}

iterator end()
{
   
   
	return _str + _size;
}

我们还提供了const版本，以供const string使用

typedef const char* const_iterator;

const_iterator begin() const
{
   
   
	return _str;
}

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

4.3范围for

这个范围for最开始压根不是C++的语法，不过后来随着Python的崛起，C++觉得这玩意挺好使，然后就直接抄过来了，但是C++底层是用迭代器替换的方式支持范围for使用的。

也就是说，这个范围for在编译完了就是迭代器，编译器给你代码替换掉了而已。

typedef char* iterator;//必须要统一名称 + 类域

iterator begin()
{
   
   
	return _str;
}

iterator end()
{
   
   
	return _str + _size;
}

typedef const char* const_iterator;

const_iterator begin() const
{
   
   
	return _str;
}

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

上面遍历方式说完了，咱们再来说一下字符/字符串插入这个话题

5.字符/字符串插入

这个地方库中是实现了很多的函数重载的，支持各种场景下的字符/字符串插入。
这个地方我为了简化只实现了其中的几个，库中实现的很多函数大体上是一样的。

5.1尾插一个字符

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

5.2尾插一个字符串

string& append(const char* str)
{
   
   
	size_t len = strlen(str);
	//扩大s的长度倍数
	if (len + _size > _capacity)
	{
   
   
		reserve(_capacity + len);
	}
	//拷贝数据
	strcpy(_str + _size, str);
	//更新_size
	_size += len;

	return *this;
}

5.3+=字符串

string& operator+=(const char* s)
{
   
   
	this->append(s);
	return *this;
}

5.4任意位置插入字符

string& insert(size_t pos,char ch)
{
   
   
	assert(pos <= _size);

	if (_size == _capacity)
	{
   
   
		reserve(_capacity == 0 ? 4 : 2 * _capacity);
	}

	//坑1：
	//size_t end = _size;
	//while (end >= pos)
	//{
   
   
	//	_str[end + 1] = _str[end];
	//	end--;
	//}
	
	//坑2：
	//int end = _size;
	//while (end >= pos)
	//{
   
   
	//	_str[end + 1] = _str[end];
	//	end--;
	//}
	
	//修改1：
	int end = _size;
	while (end >= (int)pos)
	{
   
   
		_str