STL之string类的模拟实现

目录

1. string的成员变量

2. string的成员函数 

2.1 string类的c_str()和swap()函数

2.2 string类的构造 

 2.3 string类的拷贝构造

2.3.1传统写法：

2.3.2现代写法： 

2.4string类的运算符重载 

 2.4.1传统写法：

2.4.2现代写法 

2. 5 string析构函数 

2.6 string的迭代器 

2.7 string的容量操作 

2.7.1. 有效长度与容量大小 

2.7.2. 容量操作 

2.8. string的访问操作 

2.9 string的修改操作 

2.9.1. 字符串的添加

2.9.2. 字符串的删除 

3.0 find()与substr()函数。

3.1. string的非成员函数

💓 博客主页：C-SDN花园GGbond

⏩ 文章专栏：玩转c++

为了让我们更加深入理解string，接下来我们将模拟实现一个·简易版的string。而为了和STL库中的string以示区分，我们将使用命名空间HTD对其封装。 

1. string的成员变量

string简单来说就是一个被封装可动态增长的字符数组，这与我们在数据结构中学的串非常类似，所以我们可以借助实现串的思路来大致模拟string的结构。 

下面是string的成员变量：

namespace betty
{
	class string 
    {
	public:
		//...
	private:
        char* _str;//存储的字符串
		size_t _size;//当前有效字符的个数
		size_t _capacity;//当前容量的大小，方便扩容
	};
}

注意的是\0既不占据有效长度的大小，也不占据容量的大小。 

2. string的成员函数 

2.1 string类的c_str()和swap()函数

在实现基本的构造，拷贝构造，赋值运算符重载，析构，和其他成员函数之前我们先实现c_str() 便于后续在类外使用_str成员变量来打印字符串的测试和swap（）便于进行实现拷贝构造和赋值运算符重载现代写法

注意：非成员swap（）函数在底层实际也是调用成员函数swap（）函数

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

//交换字符串
void swap(string& s)
{
	std::swap(_str, s._str);//浅拷贝，没有开空间，只是改变指针指向
	std::swap(_size, s._size);
	std::swap(_capacity, s._capacity);
}

2.2 string类的构造 

class string
{
public:
	//无参构造
	/*string()
	{
		_str = nullptr;
		_size = _capacity = 0;
	}*/
	string(const char* str = "")
	{
		_size = strlen(str);
		_capacity = _size;
		_str = new char[_capacity + 1];
		strcpy(_str, str);
	}
private:
	char* _str;
	size_t _size;
	size_t _capacity;

};

 2.3 string类的拷贝构造

2.3.1传统写法：

传统的思路就是拷贝，也就是我们先根据被拷贝的对象的_capacity开空间，然后再进行拷贝 

//拷贝构造(深拷贝)
string(const string& s)
	:_size(s._size)
	, _capacity(s._capacity)
{
	_str = new char[s._capacity + 1];
	strcpy(_str, s._str);
}

2.3.2现代写法： 

现代的思路就是，尝试去复用，比如说我们可不可以直接去利用前面的构造函数去构造一个新对象，然后再窃取新对象的成果（利用swap）

string(const string&s)
	:_str(nullptr)
{
	string tmp(s._str);
	swap(tmp);
}

2.4string类的运算符重载 

 2.4.1传统写法：

传统的思路就是，先释放掉原空间，开跟s一样的空间   拷贝字符串，更改新的_szie,_capacity

//赋值运算符重载传统写法
string& operator=(const string& s)
{
	if (this != &s)
	{
		delete[]_str;
		_str = new char[s._capacity + 1];
		strcpy(_str, s._str);
		_size = s._size;
		_capacity = s._capacity;

	}
	return *this;
}

注意：要注意自赋值情况！！否则s就被释放了 

2.4.2现代写法 

 现代的思路就是，既然被赋值这个空间不想要，那就和形参直接交换吧！！但是要注意的是，这里就不能像传统的一样用const引用了，否则不想要的空间就给到我们的赋值对象了，这边就得用传值传参，这样被交换的就只是一个临时拷贝，不想要的空间随着栈帧的结束被销毁。 

//赋值运算符重载现代写法
string& operator=(string s)
{
	swap(s);
	return *this;
}

2. 5 string析构函数 

 们实现析构函数，只需要清理资源即可

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

2.6 string的迭代器 

首先我们来模拟实现一下迭代器iterator，而在string中迭代器iterator就是一个指针。所以我们直接使用typedef实现

typedef char* iterator;
typedef const char* const_iterator;

接下来我们来实现begin()与end()，其中begin()指向的是字符串的起始位置即_str，而end()指向有效字符最后的下一位即\0的位置。 

iterator begin()
{
	return _str;
}

iterator end()
{
	return _str + _size;
}

实现完普通迭代器之后，我们可以顺便重载一个const_iterator的版本。 

const_iterator begin() const
{
	return _str;
}

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

我们知道在string中还有一个反向迭代器，这个我们在之后会统一实现。 

2.7 string的容量操作 

2.7.1. 有效长度与容量大小 

首先我们先实现返回字符串有效长度的size() 与容量大小的capacity()。并且为了适配const对象，最后用const修饰this指针。

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

2.7.2. 容量操作 

首先我们实现判断字符串是否为空的empty()以及清理字符串的clear()。其中emty()
不需要修改，可以加上const

void clear()
{
	_str[0] = '\0';
	_size = 0;//clear()函数只会将字符串的内容设置为空，而不会改变其容量不考虑capacity
}
bool empty()const
{
	return _size == 0;
}

接下来我们来实现扩容函数reserve()与·resize()，其中reserve()最简单，只要新容量大于旧容量就发生扩容。 

void string::reserve(size_t n)
{
	if (n > _capacity)
	{
		char*tmp= new char[n + 1];
		memcpy(tmp, _str, _size);
		delete[]_str;
		_str = tmp;
		_capacity = n;
	}
}
void string::resize(size_t n)
{
	if (n > _size)
	{
		if (n > _capacity)
		{
			reserve(n);
		}
		memset(_str + _size, '\0', n - _size);
	}
	
		_size = n;
		_str[_size] = '\0';
	
}

2.8. string的访问操作 

为了符合我们C语言访问数组的习惯，我们可以先重载operator[]。当然我们也要提供两种不同的接口：可读可写与可读不可写。并且使用引用返回，减少不必要的拷贝。 

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

同理我们也可以实现front()与back()函数。 

// 可读可写
char& front()
{
	return _str[0];
}
char& back()
{
	return _str[_size - 1];
}
// 可读不可写
const char& front()const
{
	return _str[0];
}
const char& back()const
{
	return _str[_size - 1];
}

2.9 string的修改操作 

2.9.1. 字符串的添加

首先我们将实现两个常用的修改函数：push_back()与append()

void push_back(char c)
{
	// 如果数据满了，则需要进行扩容
	if (_size == _capacity)
	{ 	
		reserve(_capacity == 0 ? 4 : _capacity * 2);
	}
	_str[_size++] = c;
	_str[_size] = '\0';
}
// 追加字符串
void append(const char* str)
{
	int len = strlen(str);// 获取字符串的长度
	// 如果大于原来容量，则就需要扩容
	if (_size + len > _capacity)
	{
		reserve(_size + len);
	}

	// 将字符串拷贝到末尾的_size位置
	memcpy(_str + _size, str, len + 1);
	_size += len;
}

而后我们可以复用前两个函数实现operator+=()。 

//追加一个字符
string& operator+=(char ch)
{
	push_back(ch);
	return *this;
}
//追加一个字符串
string& operator+=(const char* s)
{
	append(s);
	return *this;
}

最后我们来实现随机插入insert()函数。将pos位置和pos后所有字符移动len个单位，如果为字符len=1，否则len=字符串长度 

//添加一个字符
void insert(size_t pos, char ch)
{
    //防止越界访问
	assert(pos <= _size);
    //检查是否需要扩容
	if (_size == _capacity)
	{
		size_t newCapacity = _capacity == 0 ? 4 : _capacity * 2;
		reserve(newCapacity);
	}
	size_t end = _size + 1;
	while (end > pos)
	{
		_str[end] = _str[end - 1];
		--end;
	}
	_str[pos] = ch;
	_size++;
}
//添加一个字符串
void insert(size_t pos, const char* s)
{
    //防止越界访问
	assert(pos <= _size);
    //检查是否需要扩容
	size_t len = strlen(s);
	if (_size+len > _capacity)
	{
		reserve(_size+len);
	}
	size_t end = _size + len;
	while (end > pos)
	{
		_str[end] = _str[end - len];
		--end;
	}
	memcpy(_str + pos, s, len);
}

2.9.2. 字符串的删除 

 字符串的删除我们需要实现pop_back()与erase()两个函数。

void pop_back()
{
	_str[_size - 1] = '\0';
    --_size;
}

而随机删除erase()需要再定义一个静态类成员变量npos来实现，它为无符号数的-1，一般为整型的最大值

// 类内声明
static size_t npos;
// 类外初始化
size_t string::npos = -1;

将pos位置后所有字符往前移动len个单位，如果为字符 len=1，否则len=字符串长度 

void erase(size_t pos, size_t len = npos)
{
	assert(pos < _size);
    //判断是否将后面字符之间删除完
	if (len == npos || pos + len >= _size)
	{
		_str[0] = '\0';
		_size = pos;
	}
	else
	{
        //往前移len个字符
		size_t begin = pos + len;
		while (begin <= _size)
		{
			_str[begin - len] = _str[begin];
			++begin;
		}
		_size -= len;
	}
}

3.0 find()与substr()函数。

const char* c_str()const		
{		
    return _str;        
}
//找字符
size_t find(char ch, size_t pos = 0) const
{
	for (size_t i = pos; i < _size; i++)
	{
		if (_str[i] == ch)
		{
			return i;
		}
	}
	return npos;
}
//找字符串
size_t find(const char* s, size_t pos = 0) const
{
	const char* p = strstr(_str + pos, s);
	if (p)
	{
		return p - _str;
	}
	return npos;
}
//截取一段字符串
string substr(size_t pos, size_t len = npos)
{
    string s;
    size_t end = pos + len;
    //判断是否截取到最后
    if (len == npos || pos + len >=_size)
    {
        len = _size - pos;
        end = _size;
    }
    //提前开辟空间
    s.reserve(len);
    for (size_t i = pos; i < end; i++)
    {
        s += _str[i];
    }
    return s;
}

3.1. string的非成员函数

bool operator<(const string& s1, const string& s2)
{
	return strcmp(s1.c_str(), s2.c_str()) < 0;
}
bool operator==(const string& s1, const string& s2)
{
	return strcmp(s1.c_str(), s2.c_str())==0;
}
bool operator<=(const string& s1, const string& s2)
{
	return s1.c_str() == s2.c_str() || s1.c_str() < s2.c_str();
}
bool operator>(const string& s1, const string& s2)
{
	return strcmp(s1.c_str(), s2.c_str()) > 0;
}
bool operator>=(const string& s1, const string& s2)
{
	return s1.c_str() == s2.c_str() || s1.c_str() >s2.c_str();
}

 接下来让我们实现流插入operator<<()与流提取operator>>()。但是我们要注意普通istream对象无法提前空格与\n。这是我们就需要一个函数get()来提取

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

// 流提取
istream& operator>>(istream& in, string& s)
{
	s.clear();//先清空原字符串
	char ch = in.get();
	char buf[128];
	int i = 0;
	while (ch != '\n')//以换行为分隔符
	{
		buf[i++] = ch;
		// 为\0留空间
		if (i == 127)
		{
			buf[i] = '\0';
			s += buf;
			i = 0;
		}
		ch = in.get();
	}
	//将buf中剩余数据直接填入
	if (i != 0)
	{
		buf[i] = '\0';
		s += buf;
	}
	return in;
}