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

最新推荐文章于 2024-07-22 15:41:09 发布

盘大man

最新推荐文章于 2024-07-22 15:41:09 发布

阅读量45

点赞数

分类专栏： C++ 文章标签： c++

本文链接：https://blog.csdn.net/weixin_51134816/article/details/133818564

版权

C++ 专栏收录该内容

16 篇文章 0 订阅

订阅专栏

string的大致框架

namespace ST
{
	class string
	{
		public:
        //默认成员函数
        //.......
		private:
			char* _str;
			size_t _size;
			size_t _capacity;
			//c++的特殊处理
			//静态成员变量不能在这里给缺省值，但const静态成员变量可以
			//这里可以直接当成定义初始化
			//const static size_t npos = -1;
		public:
			static size_t npos;
	};
		size_t string::npos = -1;
}

默认成员函数

构造函数

构造函数情况：1.显示传参（string s(“hello”)） 2.不传参(string s)
故构造函数的参数需设置为全缺省参数，缺省值为"“，”“为空字符串，也是一个常量字符串
常量字符串都是以\0结尾，故”“中其实存在一个\0，虽然”\0"也是常量字符串，但其中存在两个\0，用""更好

//构造函数
string(const char* str = "")
{
	_size = strlen(str); //初始时，字符串大小设置为字符串长度
	_capacity = _size; //初始时，字符串容量设置为字符串长度
	_str = new char[_capacity + 1]; //为存储字符串开辟空间（多开一个用于存放'\0'）
	strcpy(_str, str); //将C字符串拷贝到已开好的空间
}

//构造函数方法二
string(const char* str = "\0")
	: _size(strlen(str))
	, _capacity(_size)
	, _str(new char[_capacity + 1])
{
	strcpy(_str, str);
}

在这里插入图片描述

拷贝构造函数

浅拷贝：

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

在这里插入图片描述

深拷贝：

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

在这里插入图片描述

传统写法：

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

//传统写法
string(const string& s)
	:_str(new char[s._capacity + 1])
	, _size(0)
	, _capacity(0)
{
	strcpy(_str, s._str);    //将s._str拷贝一份到_str
	_size = s._size;         //_size赋值
	_capacity = s._capacity; //_capacity赋值
}

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

在这里插入图片描述

//现代写法
string(const string& s)
	:_str(nullptr)
	, _size(0)
	, _capacity(0)
{
	string tmp(s._str); //调用构造函数，构造出一个C字符串为s._str的对象
	swap(tmp); //交换这两个对象
}

赋值运算符重载函数

传统写法：

//传统写法
string& operator=(const string& s)
{
	if (this != &s) //防止自己给自己赋值
	{
		delete[] _str; //将原来_str指向的空间释放
		_str = new char[s._capacity + 1]; //重新申请一块空间
		strcpy(_str, s._str);    //将s._str拷贝一份到_str
		_size = s._size;         //_size赋值
		_capacity = s._capacity; //_capacity赋值
	}
	return *this; //返回左值（支持连续赋值）
}

现代写法:

//现代写法1
string& operator=(string s) //编译器接收右值的时候自动调用拷贝构造函数
{
	swap(s); //交换这两个对象
	return *this; //返回左值（支持连续赋值）
}


//现代写法2
string& operator=(const string& s)
{
	if (this != &s) //防止自己给自己赋值
	{
		string tmp(s); //用s拷贝构造出对象tmp
		swap(tmp); //交换这两个对象
	}
	return *this; //返回左值（支持连续赋值）
}

析构函数

//析构函数
~string()
{
	delete[] _str;  //释放_str指向的空间
	_str = nullptr; //及时置空，防止非法访问
	_size = 0;      //大小置0
	_capacity = 0;  //容量置0
}

迭代器函数

string类中的迭代器实际上就是字符指针，只是给字符指针起了一个别名叫iterator。

typedef char* iterator;
typedef const char* const_iterator;

注意：只是string中的迭代器底层是指针，并不是所有迭代器底层都是指针。

begin，end

begin：返回字符串中第一个字符的地址

iterator begin()
{
	return _str; //返回字符串中第一个字符的地址
}
const_iterator begin()const
{
	return _str; //返回字符串中第一个字符的const地址
}

end：返回字符串中最后一个字符的后一个字符的地址（即’\0’的地址）

iterator end()
{
	return _str + _size; //返回字符串中最后一个字符的后一个字符的地址
}
const_iterator end()const
{
	return _str + _size; //返回字符串中最后一个字符的后一个字符的const地址
}

容量和大小函数

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

size：获取字符串当前的有效长度（不包括’\0’）

//大小
size_t size()const
{
	return _size; //返回字符串当前的有效长度
}

capacity：获取字符串当前的容量。

//容量
size_t capacity()const
{
	return _capacity; //返回字符串当前的容量
}

reserve：
1、当n大于对象当前的capacity时，将capacity扩大到n或大于n。
2、当n小于对象当前的capacity时，什么也不做。

//改变容量，大小不变
void reserve(size_t n)
{
	if (n > _capacity) //当n大于对象当前容量时才需执行操作
	{
		char* tmp = new char[n + 1]; //多开一个空间用于存放'\0'
		strncpy(tmp, _str, _size + 1); //将对象原本的C字符串拷贝过来（包括'\0'）
		delete[] _str; //释放对象原本的空间
		_str = tmp; //将新开辟的空间交给_str
		_capacity = n; //容量跟着改变
	}
}

注意：代码中使用strncpy进行拷贝对象C字符串而不是strcpy，是为了防止对象的C字符串中含有有效字符’\0’而无法拷贝（strcpy拷贝到第一个’\0’就结束拷贝了）。

resize：
1、当n大于当前的size时，将size扩大到n，扩大的字符为ch，若ch未给出，则默认为’\0’。
2、当n小于当前的size时，将size缩小到n。

//改变大小
void resize(size_t n, char ch = '\0')
{
	if (n <= _size) //n小于当前size
	{
		_size = n; //将size调整为n
		_str[_size] = '\0'; //在size个字符后放上'\0'
	}
	else //n大于当前的size
	{
		if (n > _capacity) //判断是否需要扩容
		{
			reserve(n); //扩容
		}
		for (size_t i = _size; i < n; i++) //将size扩大到n，扩大的字符为ch
		{
			_str[i] = ch;
		}
		_size = n; //size更新
		_str[_size] = '\0'; //字符串后面放上'\0'
	}
}

empty：string的判空函数，strcmp函数是用于比较两个字符串大小的函数，当两个字符串相等时返回0。

//判空
bool empty()
{
	return strcmp(_str, "") == 0;
}

注意：两个字符串相比较千万不能用 == 。

访问字符串函数

operator[ ]

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

//[]运算符重载（可读可写）
char& operator[](size_t i)
{
	assert(i < _size); //检测下标的合法性
	return _str[i]; //返回对应字符
}

//[]运算符重载（只读）
const char& operator[](size_t i)const
{
	assert(i < _size); //检测下标的合法性
	return _str[i]; //返回对应字符
}

find函数

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

//正向查找第一个匹配的字符
size_t find(char ch, size_t pos)
{
	assert(pos < _size);
	for (size_t i = pos; i < _size; i++)
	{
		if (ch == _str[i])
		{
			return i;
		}
	}
	return npos;
}


//正向查找第一个匹配的字符串
size_t find(const char* str, size_t pos = 0)
{
	assert(pos < _size); //检测下标的合法性
	const char* ret = strstr(_str + pos, str); //调用strstr进行查找
	if (ret) //ret不为空指针，说明找到了
	{
		return ret - _str; //返回字符串第一个字符的下标
	}
	else //没有找到
	{
		return npos; //返回npos
	}
}

rfind函数

反向查找第一个匹配的字符或字符串。

对于查找字符：可以将对象的C字符串逆置，然后再用find函数查找字符，

对于查找字符串：将对象的C字符串逆置的同时，还需将待查找的字符串逆置，然后再用find函数查找

注意：逆置后，传入find函数的pos需要镜像对称一下。

1、反向查找第一个匹配的字符。
先用对象拷贝构造一个临时对象tmp，防止逆置操作影响原来的字符串。将tmp对象的C字符串逆置，然后将所给pos镜像对称一下再调用find函数，再将从find函数接收到的返回值镜像对称一下作为rfind函数的返回值返回即可。

//反向查找第一个匹配的字符
size_t rfind(char ch, size_t pos = npos)
{
	string tmp(*this); //拷贝构造对象tmp
	reverse(tmp.begin(), tmp.end()); //调用reverse逆置对象tmp的C字符串
	if (pos >= _size) //所给pos大于字符串有效长度
	{
		pos = _size - 1; //重新设置pos为字符串最后一个字符的下标
	}
	pos = _size - 1 - pos; //将pos改为镜像对称后的位置
	size_t ret = tmp.find(ch, pos); //复用find函数
	if (ret != npos)
		return _size - 1 - ret; //找到了，返回ret镜像对称后的位置
	else
		return npos; //没找到，返回npos
}

2、反向查找第一个匹配的字符串。
先用对象拷贝构造一个临时对象tmp，然后将tmp对象的C字符串逆置，待查找的字符串也同样操作。然后将所给pos镜像对称一下再调用find函数。

注意：此时我们将从find函数接收到的值镜面对称后，得到的是待查找字符串的最后一个字符在对象C字符串中的位置，而我们需要返回的是待查找字符串在对象C字符串中的第一个字符的位置，所以还需做进一步调整后才能作为rfind函数的返回值返回。

//反向查找第一个匹配的字符串
size_t rfind(const char* str, size_t pos = npos)
{
	string tmp(*this); //拷贝构造对象tmp
	reverse(tmp.begin(), tmp.end()); //调用reverse逆置对象tmp的C字符串
	size_t len = strlen(str); //待查找的字符串的长度
	char* arr = new char[len + 1]; //开辟arr字符串（用于拷贝str字符串）
	strcpy(arr, str); //拷贝str给arr
	size_t left = 0, right = len - 1; //设置左右指针
	//逆置字符串arr
	while (left < right)
	{
		::swap(arr[left], arr[right]);
		left++;
		right--;
	}
	if (pos >= _size) //所给pos大于字符串有效长度
	{
		pos = _size - 1; //重新设置pos为字符串最后一个字符的下标
	}
	pos = _size - 1 - pos; //将pos改为镜像对称后的位置
	size_t ret = tmp.find(arr, pos); //复用find函数
	delete[] arr; //销毁arr指向的空间，避免内存泄漏
	if (ret != npos)
		return _size - ret - len; //找到了，返回ret镜像对称后再调整的位置
	else
		return npos; //没找到，返回npos
}

修改字符串函数

push_back

在当前字符串的后面尾插上一个字符

尾插之前首先需要判断是否需要增容，若需要，则调用reserve函数进行增容，然后再尾插字符，

注意：尾插完字符后需要在该字符的后方设置上’\0’，否则打印字符串的时候会出现非法访问，因为尾插的字符后方不一定就是’\0’。

//尾插字符
void push_back(char ch)
{
	if (_size == _capacity) //判断是否需要增容
	{
		reserve(_capacity == 0 ? 4 : _capacity * 2); //将容量扩大为原来的两倍
	}
	_str[_size] = ch; //将字符尾插到字符串
	_str[_size + 1] = '\0'; //字符串后面放上'\0'
	_size++; //字符串的大小加一
}

//尾插字符
void push_back(char ch)
{
	insert(_size, ch); //在字符串末尾插入字符ch
}

注：增容时以二倍的形式进行增容，避免多次调用push_back函数时每次都需要调用reserve函数。

append

在当前字符串的后面尾插一个字符串

尾插前需要判断当前字符串的空间能否容纳下尾插后的字符串，若不能，则需要先进行增容，然后再将待尾插的字符串尾插到对象的后方

//尾插字符串
void append(const char* str)
{
	size_t len = _size + strlen(str); //尾插str后字符串的大小（不包括'\0'）
	if (len > _capacity) //判断是否需要增容
	{
		reserve(len); //增容
	}
	strcpy(_str + _size, str); //将str尾插到字符串后面
	_size = len; //字符串大小改变
}

//尾插字符串
void append(const char* str)
{
	insert(_size, str); //在字符串末尾插入字符串str
}

operator+=

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

//+=运算符重载
string& operator+=(char ch)
{
	push_back(ch); //尾插字符串
	return *this; //返回左值（支持连续+=）
}

//+=运算符重载
string& operator+=(const char* str)
{
	append(str); //尾插字符串
	return *this; //返回左值（支持连续+=）
}

insert

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

插入字符：

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

//在pos位置插入字符
string& insert(size_t pos, char ch)
{
	assert(pos <= _size); //检测下标的合法性
	if (_size == _capacity) //判断是否需要增容
	{
		reserve(_capacity == 0 ? 4 : _capacity * 2); //将容量扩大为原来的两倍
	}
	char* end = _str + _size;
	//将pos位置及其之后的字符向后挪动一位
	while (end >= _str + pos)
	{
		*(end + 1) = *(end);
		end--;
	}
	_str[pos] = ch; //pos位置放上指定字符
	_size++; //size更新
	return *this;
}

插入字符串：

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

//在pos位置插入字符串
string& insert(size_t pos, const char* str)
{
	assert(pos <= _size); //检测下标的合法性
	size_t len = strlen(str); //计算需要插入的字符串的长度（不含'\0'）
	if (len + _size > _capacity) //判断是否需要增容
	{
		reserve(len + _size); //增容
	}
	char* end = _str + _size;
	//将pos位置及其之后的字符向后挪动len位
	while (end >= _str + pos)
	{
		*(end + len) = *(end);
		end--;
	}
	strncpy(_str + pos, str, len); //pos位置开始放上指定字符串
	_size += len; //size更新
	return *this;
}

注意：插入字符串的时候使用strncpy，不能使用strcpy，否则会将待插入的字符串后面的’\0’也插入到字符串中。

erase

删除字符串任意位置开始的n个字符

进行删除操作的时候分两种情况：
1、pos位置及其之后的有效字符都需要被删除。这时我们只需在pos位置放上’\0’，然后将对象的size更新即可。

2、pos位置及其之后的有效字符只需删除一部分。这时我们可以用后方需要保留的有效字符覆盖前方需要删除的有效字符，此时不用在字符串后方加’\0’，因为在此之前字符串末尾就有’\0’了。

//删除pos位置开始的len个字符
string& erase(size_t pos, size_t len = npos)
{
	assert(pos < _size); //检测下标的合法性
	size_t n = _size - pos; //pos位置及其后面的有效字符总数
	if (len >= n) //说明pos位置及其后面的字符都被删除
	{
		_size = pos; //size更新
		_str[_size] = '\0'; //字符串后面放上'\0'
	}
	else //说明pos位置及其后方的有效字符需要保留一部分
	{
		strcpy(_str + pos, _str + pos + len); //用需要保留的有效字符覆盖需要删除的有效字符
		_size -= len; //size更新
	}
	return *this;
}

clear

用于将对象中存储的字符串置空

//清空字符串
void clear()
{
	_size = 0; //size置空
	_str[_size] = '\0'; //字符串后面放上'\0'
}

swap

交换两个对象的数据

//交换两个对象的数据
void swap(string& s)
{
	//调用库里的swap
	::swap(_str, s._str); //交换两个对象的C字符串
	::swap(_size, s._size); //交换两个对象的大小
	::swap(_capacity, s._capacity); //交换两个对象的容量
}

c_str

对象C类型的字符串，即获取对象的_str

对象中包括str,size,capacity等，故不能直接用对象进行字符串的操作，需要像size()函数一样获取到对象某个特定的特征值

//返回C类型的字符串
const char* c_str()const
{
	return _str;
}

关系运算符函数

//>运算符重载
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) || (*this == s);
}
//<运算符重载
bool operator<(const string& s)const
{
	return !(*this >= s);
}
//<=运算符重载
bool operator<=(const string& s)const
{
	return !(*this > s);
}
//!=运算符重载
bool operator!=(const string& s)const
{
	return !(*this == s);
}

getline函数

getline函数用于读取一行含有空格的字符串。读取到’\n’时停止读取字符。

//读取一行含有空格的字符串
istream& getline(istream& in, string& s)
{
	s.clear(); //清空字符串
	char ch = in.get(); //读取一个字符
	while (ch != '\n') //当读取到的字符不是'\n'的时候继续读取
	{
		s += ch; //将读取到的字符尾插到字符串后面
		ch = in.get(); //继续读取字符
	}
	return in;
}

>>运算符的重载

重载>>运算符是为了让string对象能够像内置类型一样使用>>运算符直接输入。输入前我们需要先将对象的C字符串置空，然后从标准输入流读取字符，直到读取到空格或是’\n’便停止读取。

注意：不能使用in从缓冲区获取字符，in获取不到空格和\n，当输入空格时，它会以为是在输入字符与字符之间的间隔

若是字符串很长，不断的+=，频繁扩容，就会导致效率很低

这时，就可以定义一个存储字符的数组buff，设置其容量为稍大的数，例如32

获取到的字符串就可以先存储在buff中，buff放满了就直接一次性添加到s中，这样s扩容就可以一次性直接扩容，不用一次一次扩
当s中原来就存在字符串时，需要将其清空

istream& operator>>(istream& in, string& s)
{
	char ch;
    //库中string的特性，当s中原来就存在字符串时，需要将其清空
	s.clear();
	ch = in.get();
	const size_t N = 32;
	char buff[N];
	size_t i = 0;
	while (ch != ' ' && ch != '\n')
	{
        //将获取到的字符串先存储在buff中
		buff[i++] = ch;
        //i==N-1时，表示buff满了
		if (i == N - 1)
		{
			buff[i] = '\0';
            //buff放满了就直接一次性添加到s中
			s += buff;
            //i置为0是为了继续往buff中从头开始添加字符串
			i = 0;
		}
		ch = in.get();
	}
	buff[i] = '\0';
	s += buff;
	return in;
}

<<运算符的重载

重载<<运算符是为了让string对象能够像内置类型一样使用<<运算符直接输出打印。实现时我们可以直接使用范围for对对象进行遍历即可。

//<<运算符的重载
ostream& operator<<(ostream& out, const string& s)
{
	//使用范围for遍历字符串并输出
	for (auto e : s)
	{
		cout << e;
	}
	return out; //支持连续输出
}

盘大man

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
C++STL----string类的模拟实现

此时我们将从find函数接收到的值镜面对称后，得到的是待查找字符串的最后一个字符在对象C字符串中的位置，而我们需要返回的是待查找字符串在对象C字符串中的第一个字符的位置，所以还需做进一步调整后才能作为rfind函数的返回值返回。因为拷贝对象的_str与源对象的_str指向的并不是同一块空间，所以拷贝出来的对象与源对象是互相独立的。尾插前需要判断当前字符串的空间能否容纳下尾插后的字符串，若不能，则需要先进行增容，然后再将待尾插的字符串尾插到对象的后方。其中一个对象的改动会对另一个对象造成影响。
复制链接

扫一扫