string类的模拟实现(C++)

一、前言

想要模拟实现一个库中的类，那就要首先要熟悉如何使用这个类。建议通过下面博客，完成对C++string类的学习。

C++的string类-CSDN博客

二、模拟实现

我们将从string的成员函数即成员变量入手，模拟实现string类。

成员变量

string类的实现并未给出对应的标准，因此实现比较多样。为了防止出现命名冲突，我们将自己实现的string独自封装到单独的命名空间。下面是string的成员变量的实现。

namespace MyString
{
	class string
	{
 
 
 
	private:
		char* _a;
		size_t _size;
		size_t _capacity;
	};
	
 
}

string我们可以看成是由数组、数组大小、数组空间构成的一个类。

成员函数

由于string的成员函数写的十分冗余，被业内也大量吐槽，因此我们实现几个主要的成员方法，也是最常用的几个成员方法。

构造函数：

构造函数用来实现函数调用时的初始化，需要注意的是，在初始化时，初始化列表阶段走的顺序不是写入初始化列表的顺序，而是成员变量的声明顺序。

需要注意两个个坑点：

坑点一：const char* 不能去初始化char*

当我们开始实现时，发现程序报错了，这是为什么呢？

这是因为：const char*类型的值不能用于初始化char*类型的值。

在C++中，const char*和char*之间的区别与C语言中的相同：const char*是指向常量字符的指针，意味着通过这个指针你不能修改所指向的字符。这种类型通常用于指向字符串字面量，因为这些字面量在程序中是只读的，存储在程序的常量区。

那就意味着，我们无法用_a指向str。因此我们需要给_a额外开辟一块空间，将str的值拷贝到这块空间。

坑点二：初始化列表走的顺序是变量声明的顺序

string::string(const char* str)
	:_a(new char[_capacity + 1])
	,_size(strlen(str))
	, _capacity(_size + 1)
{}

有了上面的经验，我们想把_a开辟一块新空间，把内容拷贝进去。但是上述的代码也是不正确的！

我们出初始化先走的是_a，给_a开辟空间的时候，_capacity并未初始化，因此_capacity + 1的大小是未定义的。

正确方法：

为了合理的初始化顺序（重点观众声明顺序），我们采用初始化列表和函数体共同使用的方法去初始化构造函数。

string::string(const char* str)
	:_size(strlen(str))
	, _capacity(_size)
{
	_a = new char[_capacity + 1];	//多开一个存储\0
	strcpy(_a, str);		//strcpy会给dest字符串，自动添加\0
}

我们先控制好大小之后，再去开辟空间，完成对_a的初始化。

优化：

先说明一个知识。“” 这个字符串代表的是常量字符串，长度是0。

int main()
{
	cout << strlen("") << endl;
 
	return 0;
}

上述给出的构造函数，并不是默认构造，因为我们没有给出缺省值。下面通过给出一个默认的常量字符串，完成初始化。

string::string(const char* str = "")
	:_size(strlen(str))		//默认常量字符串长度： 0
	, _capacity(_size) 
{
	_a = new char[_capacity + 1];	//多开一个存储\0
	strcpy(_a, str);		//strcpy会给dest字符串，自动添加\0
}

当我们不给出参数时，会使用缺省的长脸字符串，_size == 0 ;  _capacity == 0;  _a的大小是1（给\0预留空间）。

通过初始化列表与函数体的结合使用，这个函数便实现了默认构造与构造函数的结合。

析构函数

析构函数的任务是完成数据的销毁与资源的释放。在string中，需要完成如下。

string::~string()	
{
	_size = _capacity = 0;
	delete[] _a;
	_a = nullptr;	//需要让指针置空
 
}

c_str

c_str可以返回数组，并且返回的类型兼容C语言数组的属性。

const char* string::c_str() const
{
    return _a;
}

[]重载

由于[]存在读和写两种两种需求，所以需要写出重载函数，来完成读和写的功能。在返回时，应尽量采用引用返回。同时应该注意assert去检查给出的下标是否合法。

char& string::operator[] (size_t pos)
{
	assert(pos <= _size - 1);	//pos是size_t，所以 >=0 恒成立
	return _a[pos];
}
 
const char& string::operator[] (size_t pos) const
{
	assert(pos <= _size - 1);
	return _a[pos];
}

capacity、size

size_t string::capacity() const
{
	return _capacity;
}

应该用const修饰函数，保证const成员与非const成员都可以访问。

size_t string::size() const
{
	return _size;
}

reserve

reserve函数用来完成空间的修正。对_capacity进行修正。一般来说空间大小只增不减，因此只有当作新空间大小大于原来空间大小的时候，才能进行开辟空间操作。

对于C++而言，开辟空间我们一般用new。因此reserve函数的实现必然包含以下步骤：1.开辟新空间 2.内容拷贝 3.释放旧空间（防止泄露）

void string::reserve(size_t n)	//开辟空间,对_capacity作出修改
{
	//1.重新开空间	2.深拷贝 3.释放旧空间
 
	if (n > _capacity)
	{
		char* tmp = new char[n + 1];
		memcpy(tmp, _a, _size + 1);
		delete[] _a;
		_a = tmp;
		_capacity = n;	//将空间修正为n
	}
 
}

push_back

功能是尾插。需要额外注意，空间是否还有剩余。在尾插完成之后，需要人为添加\0，使得C++能够兼容C。

void string::push_back(char ch)
{
	if (_size == _capacity)	//利用reserve扩容
	{
		reserve(_capacity == 0 ? 4 : 2 * _capacity);
	}
 
	_a[_size] = ch;
	++_size;	//_size类比length
	_a[_size] = 0;	//补充\0，符合C语言的规范
}

append

字符串的追加。字符串的追加也需要扩容，但是不是简单的二倍扩容这么简单，扩容时需要保证扩容后的大小必须可以容纳新的字符串。

在追加时可以用strcpy函数，strcpy的特性在代码中有所体现。

void string::append(const char* str)	//追加字符串
{
	size_t len = strlen(str);
 
	if (len + _size > _capacity)
		reserve(len + _size);
 
	strcpy(_a + _size, str);	//从_size处，完成内容的拷贝
	/*
		strcpy ：自动添加\0，可从任意位置开始拷贝
	*/
 
	_size += len;
}

operator+=

完成字符与字符串的追加。返回的*this就是对象

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

insert

完成任意位置的插入。需要额外注意  1.头插和尾插能不能完成。 2.\0需要完成移动

因此我们直接借助下标end = _size+1；即可完成数据的移动

 
void string::insert(size_t pos, char ch)
{
	assert(pos <= _size);		// = 是尾插
 
	if (_size == _capacity)	//利用reserve扩容
	{
		reserve(_capacity == 0 ? 4 : 2 * _capacity);
	}
 
	size_t end = _size + 1;	//保证可以完成头插
 
	while (end > pos)	//后移（包含\0）
	{
		_a[end] = _a[end - 1];
		--end;
	}
 
	_a[pos] = ch;
	++_size;
	//_a[_size] = 0;	//可有可无，\0也发生了后移
}

 
void string::insert(size_t pos, const char* str)
{
	assert(pos <= _size);		//不需要检查是否>0
	size_t len = strlen(str);
 
	if (len + _size > _capacity)
		reserve(len + _size + 1);	//对this指针对象进行扩容
 
	int end = _size;	//防止出现size_t的死循环
	while (end >= (int)pos)
	{
		_a[end + len] = _a[end];
		--end;
	}
	
	strncpy(_a + pos, str, len);	
	_size += len;
 
}

注意，当需要完成字符串的插入时，最好用int作为end的类型，防止出现死循环，同时强转pos类型（防止出现提升）。

/*
strncpy 函数在C语言中用于拷贝字符串。它的原型是：

char *strncpy(char *dest, const char *src, size_t n);
这个函数从源字符串 src 拷贝至目标字符串 dest，最多拷贝 n 个字符。
如果源字符串的长度小于 n，strncpy 会在目标字符串后面添加额外的空字符 ('\0')，直到总共拷贝了 n 个字符。
如果源字符串的长度大于或等于 n，则不会在目标字符串后面添加空字符。
*/

erase

用来完成删除操作。值得一提的是，缺省参数在声明时可以给出，在定义时不可以给出。

 
void string::erase(size_t pos, size_t len)		//声明给出，定义不给出缺省
{
	assert(pos < _size);		// == _size是\0的位置，不能删除
 
	if (len == npos || pos + len >= _size)	//len过长时
	{
		_a[pos] = 0;
		_size = pos;
	}
 
	else	//len的长度合适时
	{
		int cur = pos + len;
 
		while (cur <= (int)_size)
		{
			_a[pos++] = _a[cur++];
		}
 
		_size -= len;
	}
}

clear

Erases the contents of the string, which becomes an empty string (with a length of 0 characters).

清楚内容，长度清零。

void string::clear()
{
	_size = 0;
	_a[0] = 0;
}

函数重载

只要完成 ==  >就可以服用全部重载。

 
bool string::operator<(const string& s) const
{
	return strcmp(_a, s._a) < 0;		//内部可使用private成员
}
 
bool string::operator==(const string& s) const
{
	return strcmp(_a, s._a) == 0;
}
 
bool string::operator<=(const string& s) const
{
	return *this == s || *this < s;
}
 
bool string::operator>(const string& s) const
{
	return !(*this <= s);
}
 
bool string::operator>=(const string& s) const
{
	return !(*this < s);
}
 
bool string::operator!=(const string& s) const
{
	return !(*this == s);
}

迭代器函数

对于迭代器的实现有很多种方式，可以采用下标，可以采用指针。实现方式没有明确规定，我们这里采用指针来实现。

public:
    typedef char* iterator;        //typedef受到访问权限的限制
    typedef const char* const_iterator;
 

在类的内部，将迭代器iterator有指针类型实现。typedef收到访问权限的限制。

 
string::iterator string::begin()
{
	return _a;
}
 
string::iterator string::end()
{
	return _a + _size;	//end返回的是最后一个元素的下一个位置。
}
 
string::const_iterator string::begin() const
{
	return _a;
}
 
string::const_iterator string::end() const
{
	return _a + _size;
}
 

需要注意的是end是最后一个元素的下一个位置。

/*
在C++中，迭代器的`end()`函数代表的是最后一个元素的下一位置。
它是用来标记容器的超出末端的位置，所以在进行遍历等操作时，通常会使用这个迭代器来检查是否到达了容器的末尾。
例如，如果你有一个 vector 容器，并且想要遍历它，你可以这样做：

std::vector<int> vec = {1, 2, 3, 4, 5};
for (auto it = vec.begin(); it != vec.end(); ++it) {
    std::cout << *it << std::endl;
}
在这个循环中，`it` 会在每次迭代后递增，直到它等于 `vec.end()`，这时循环结束。
在循环体中，`*it` 是有效的并且指向当前的元素，当 `it` 达到 `vec.end()` 时，它不再指向任何元素，因此不应该被解引用。

*/

赋值重载与拷贝构造

string内部提供了swap函数，我们可以借助swap函数进行标题函数的实现。

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

在swap内部，交换三个成员变量。

拷贝构造的实现：1.完成初始化 2.swap 一下tmp与*this

//s1(s2)
string::string(const string& s)	//在进入函数体之前，先对this进行初始化
	:_a(nullptr)
	, _size(0)
	, _capacity(_size)
 
{
	string tmp(s._a);
	swap(tmp);
}

/*
在C++中，未初始化的对象是不应该调用析构函数的。
析构函数是用来释放对象所拥有的资源的，如果一个对象没有被正确地初始化，
它可能没有分配资源，或者分配的资源处于未知的状态。
在这种情况下调用析构函数可能会导致未定义行为（UB），包括程序崩溃或者数据损坏。
*/
 

赋值重载的实现：同样借助swap函数。假设S2 = S3，那我们利用S3生成一个形参，swap S2 形参即可。交换完成之后，形参出作用域也可以自动销毁。同时为了保证=的连续性，返回类型应该是string对象类型。

// s2 = s3
string& string::operator=(string tmp)	//直接形参接收
{
	swap(tmp);
	return *this;		//保证返回类型也是string，可以连等
}

resize

resize用来修改size的大小。可分为两个情况讨论。void string::resize(size_t n, char ch)    //更新size

当n >= _size 和 n < _size。分别对应扩大size和缩小size

void string::resize(size_t n, char ch)	//更新size
{
	if (n <= _size)
	{
		_size = n;
		_a[_size] = 0;
	}
	else
	{
		reserve(n);		//函数内部开辟n + 1个空间
		
		while (_size < n)
		{
			_a[_size++] = ch;
		}
 
		_a[_size] = 0;
	}
}

find

用来查找内容，可以查找字符或者字符串。

查找字符

size_t string::find(char ch, size_t pos)	//函数的定义不能有缺省值
{
	for (size_t i = pos; i < _size; ++i)
	{
		if (_a[i] == ch)
			return i;
	}
 
	return npos;
}

查找字符串有两种方法：方法一，使用strstr函数

 
size_t string::find(const char* sub, size_t pos)
{
	const char* ptr = strstr(_a + pos, sub);
	if (ptr == nullptr)
		return npos;
	return ptr - _a;
}

方法二：自己实现功能的查找

需要遍历str1，去找到第一个匹配的字符，匹配成功之后后移。

/*
思路：遍历原数组，匹配往后走。
*/
 
size_t string::find(const char* sub, size_t pos = 0)
{
	assert(pos < _size);
	size_t i = pos;
 
	for (; i < _size; ++i)		//遍历原数组
	{
		if (_a[i] == sub[0])
		{
			size_t len = strlen(sub);
			size_t m = i;
 
			for (size_t j = 0; j < len; ++j)	//循环：判断
			{
				if (m >= _size || sub[j] != _a[m])		
				{
					break;
				}
				++m;	//后移
			}
 
			if (m - i == len)	//如果完全一致（长度替代flag）
				return i;
 
 
		}
	}
 
	return npos;
 
}

m - i == len则表示两个字符串完全一致。不能直接在判断语句写出m++。由于m在每次比较后都会递增，所以m - i的计算可能不会反映实际的匹配长度，因为m可能会超出实际不匹配的位置。即位置匹配成功之后，才可以m++。

substr

用来生成子串。其核心逻辑是1.设定好大小开空间 2.拷贝内容

开大小：确定合适的长度        拷贝内容：确定合适的终止位置end

 
//1.设定好大小开空间 2.拷贝内容
string string::substr(size_t pos, size_t len)
{
	assert(pos < _size);
	string tmp;
	size_t end = pos + len;
	//设定大小
	if (pos + len >= _size || len == npos)	//len太长
	{
		len = _size - pos;
		end = _size;
	}
 
	tmp.reserve(len);	//开空间
 
	for (size_t i = pos; i < end; i++)	//内容拷贝
	{
		tmp += _a[i];
	}
 
	return tmp;		//临时对象不用引用返回。
}

全局函数

    ostream& operator<<(ostream& out, const string& s);

string函数支持直接流提取与流插入的操作。

流提取

ostream& MyString::operator<<(ostream& out, const string& s)
{
	for (auto ch : s)	//写了迭代器之后，就可以用范围for
		out << ch;
	return out;
}

流插入

我们借助一个插入缓冲区，来防止过多的浪费空间。步骤：1.输入内容 2.流入缓冲区 3.从缓冲区提取内容 4.继续从将内容读取到缓冲区中  最后需要清除缓冲区

 
istream& MyString::operator>>(istream& in, string& s)
{
	s.clear();	//清空对象
	char ch = in.get();
	size_t i = 0;
	char* buff = new char[129];		//建立缓冲区
 
	while (ch != ' ' && ch != 10)
	{
		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;
 
}