string类详解及重要函数实现

一颗青果

已于 2024-03-23 09:45:26 修改

阅读量826

点赞数 40

分类专栏： c++大冒险文章标签：开发语言 c++

于 2024-03-23 00:50:35 首次发布

本文链接：https://blog.csdn.net/2301_79551553/article/details/136923752

版权

c++大冒险专栏收录该内容

21 篇文章 3 订阅

订阅专栏

🪐🪐🪐欢迎来到程序员餐厅💫💫💫

今日主菜：string类

主厨：邪王真眼

所属专栏：c++专栏

主厨的主页：Chef‘s blog

前言：

咱们之前也是打开了c++的大门，相信很多朋友对这门新的语言都充满了好奇，那么今天就来份硬菜满足一下各位，铛铛铛铛，c++第二座大山：STL之string，他来了！

【本节目标】

1. 为什么要学习string类

2. 标准库中的string类

3. string类的模拟实现

1. 为什么学习string类？

1.1 C语言中的字符串

C 语言中，字符串是以 '\0' 结尾的一些字符的集合，为了操作方便， C 标准库中提供了一些 str 系列的库函数，

但是这些库函数与字符串是分离开的，不太符合 OOP（面向对象）的思想，而且底层空间需要用户自己管理，稍不留神可能还会越界访问。

1.2 编程题解答

在 OJ 中，有关字符串的题目基本以 string 类的形式出现，而且在常规工作中，为了简单、方便、快捷，基本都使用string 类，很少有人去使用 C 库中的字符串操作函数。

2. 标准库中的string类

2.1 string类是什么

1. 他是一个成员变量包含字符指针的类，有多种与字符指针有关的的接口，可以对他进行多种操作

2.在使用string类时，必须包含#include<string>以及using namespace std;

2.2string的构造函数

2.2.1介绍

void Teststring()
{
 string s1; // 构造空的string类对象s1
 string s2("hello"); // 用C格式字符串构造string类对象s2
 string s3(s2); // 拷贝构造s3
}

2.2.2代码实现：

我们基本不用第三种，所以这里只实现 124，我们把12通过缺省参数来结合

class string
{
public:
	string(const char* str = "")//"\0"=="",因为结尾没有'\0'会补
		: _size(strlen(str))
		, _capacity(_size == 0 ? 3 : _size)
	{
		_str = new char[_capacity + 1];//_capacity不包括最后的'\0'
		strcpy(_str, str);
	}

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

private:
	char* _str;
	size_t _size;//大小不包括'\0',表示这个字符指针所容纳的字符数量
	size_t _capacity;//大小不包括'\0'，表示字符指针指向的空间的大小，即开辟的空间大小
};

2.3 string类对象的容量操作

2.3.1介绍

注意：

1. size()与length()方法底层实现原理完全相同，因为string的出现是早于STL的，一开始也只有length，但后来在STL中别的容器（例如队列，链表，树）用的都是size，为了保证接口一致，于是又给string设计了size接口，一般情况下基本都是用size()。
2. clear()只是将string中有效字符清空，不改变底层空间大小。

3. reserve：为string预留空间，不改变有效元素个数，当reserve的参数小于 string的底层空间总大小时，reserver不会改变容量大小。
4. resize(size_t n) 与 resize(size_t n, char c) 都是将字符串中有效字符个数改变到 n 个，不同的是当字符个数增多时：resize(n) 用 0 来填充多出的元素空间， resize(size_t n, char c) 用字符 c 来填充多出的元素空间。注意：resize 在改变元素个数时，如果是将元素个数增多，可能会改变底层容量的大小，如果是将元素个数减少，底层空间总大小不变。我们也是利用缺省参数将二者合并。

2.3.2代码实现

class string
	{
	public:
		size_t size()const//length的实现与它完全一样，就是名字不一样
		{
			return _size;
		}
		size_t capacity()const
		{
			return _capacity;
		}
		bool empty()
		{
			return _size == 0;
		}
		void clear()
		{
			strcpy(_str, "");
			_size = 0;
		}
		void reserve(size_t a)
		{
			if (a > _capacity)//扩容，那就要重新开辟一份空间
			{
				char* str = new char[a + 1];
				strcpy(str, _str);//将原本的数拷贝到开的空间
				delete[] _str;//释放原来的空间，防止内存泄漏
				_str = str;
				_capacity = a;//更改所记录的容量值
			}

		}
		void resize(size_t a,char ch='\0')
		{

			if (a > _capacity)
			{
				char* str = new char[a + 1];//记得多开一个给'\0'
				strcpy(str, _str);
				delete[] _str;
				_str = str;
				while (_size != a)//将多余的空间进行赋初值
				{
					_str[_size] = ch;
				}
				_str[_size] = '\0';
				_capacity = a;
			}
			else
			{
				_size = a;
				_str[_size] = '\0';//不缩容，只要改记录的_size就好了
			}
		}
		private:
		char* _str;
		size_t _size;//大小不包括'\0',表示这个字符指针所容纳的字符数量
		size_t _capacity;//大小不包括'\0'，表示字符指针指向的空间的大小，即开辟的空间大小
	};

2.4. string类对象的访问及遍历操作

2.4.1介绍

2.4.2代码实现

class string
{
public:
	char& operator[](size_t pos)//重载一下，对应传参const和非const
	{
		assert(pos < _size);//先判断有没有越界
		return _str[pos];直接返回所求的下标的值，记住是传引用，因为可能需要修改
	}
	const char& operator[](size_t pos)const
	{
		assert(pos < _size);
		return _str[pos];
	}
	typedef char* iterator;//我们命名了两种迭代器，用于后面对于const和非const的返回值类型
	typedef const char* const_iterator;对于string类,所谓迭代器就是char*指针
	iterator begin()//返回存储字符开始的空间的指针
	{
		return _str;
	}
	iterator end()
	{
		return _str + _size返回最后指向'\0'的指针;
	}
	const_iterator begin()const
	{
		return _str;
	}
	const_iterator end()const
	{
		return _str + _size;
	}
	private:
	char* _str;
	size_t _size;//大小不包括'\0',表示这个字符指针所容纳的字符数量
	size_t _capacity;//大小不包括'\0'，表示字符指针指向的空间的大小，即开辟的空间大小
};

2.4.3范围for：

范围for的实现就是依靠迭代器：看代码

for (auto& c : d)//不能out<<_str,因为可能中间有'\0'
	out << c;
for (string::iterator it = d.begin(); it < d.end(); it++)
	cout << *it;

这两个循环是完全等价的，事实上，编译器就是会在编译时把上面的循环转化为下面的迭代器循环，证据就是范围for的反汇编代码：

2.5. string类对象的修改操作

2.5.1介绍

注意：

1. 在string尾部追加字符时，s.push_back(c) / s.append(1, c) / s += 'c'三种的实现方式差不多，一般情况下string类的+=操作用的比较多，+=操作不仅可以连接单个字符，还可以连接字符串。
2. 对string操作时，如果能够大概预估到放多少字符，可以先通过reserve把空间预留好。

2.5.2代码实现：

class string
{
public:
	string& operator+=(const char* str)
	{
		this->append(str);//与append作用相同，所以直接调用函数
		return *this;
	}
	string& operator+=(const char ch)//与push_back作用相同，所以直接调用函数
	{
		this->push_back(ch);
		return *this;
	}
	string& operator+=(const string& s)
	{
		this->append(s._str);//与append作用相同，所以直接调用函数
		return *this;
	}
	void push_back(const char ch)
	{
		if (_size + 1 > _capacity)//就扩容
		{
			reserve(_capacity * 1.5);//1.5倍扩容
		}
		_str[_size] = ch;
		_size++;
		_str[_size] = '\0';//结尾是'\0'别忘了
	}
	void append(const char* str)
	{
		size_t len = strlen(str);
		if (_size + len > _capacity)//就扩容
		{
			reserve(_capacity + len);
		}
		strcpy(_str + _size, str);
		_size += len;//——capacity已经在reserve中调整过了
	}
	size_t find(const char ch, size_t pos = 0)//从下标为pos出开始查找，看有没有目标字符
	{
		assert(pos < _size);
		for (size_t i = pos; i < _size; i++)
		{
			if (_str[i] == ch)
				return i;
		}
		return npos;
	}
	size_t find(const char* str, size_t pos = 0)
	{
		assert(pos < _size);
		char* p = strstr(_str + pos, str);从下标为pos出开始查找，看有没有目标字符串
		if (p == nullptr)
			return npos;//npos的值就是无符号数的-1，也就是42亿多
		return p - _str;
	}
	const char* c_str()
	{
		return _str;
	}
private:
	char* _str;
	size_t _size;//大小不包括'\0',表示这个字符指针所容纳的字符数量
	size_t _capacity;//大小不包括'\0'，表示字符指针指向的空间的大小，即开辟的空间大小
	static size_t npos;
};
size_t string::npos = -1;

2.6赋值运算操作符重载

string& operator=(const string& s)
{
	if (this != &s)
	{
		char* tmp = new char[s._size + 1];
		strcpy(tmp, s._str);
		//抛异常
		delete[]_str;
		_str = tmp;
		_size = s._size;
		_capacity = _size;

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

2.7. string类非成员函数

2.7.1介绍

2.7.2代码实现

	ostream& operator<<(ostream& out, string& d)
	{
		for (auto& c : d)//不能out<<_str,因为可能中间有'\0'
			out << c;
		for (string::iterator it = d.begin(); it < d.end(); it++)
			cout << *it;
		return out;
	}
	istream& operator>>(istream& in, string& s)
	{
		s.clear();
		char ch;
		char buff[128] = { 0 };
		int i = 0;
		ch = in.get();//直接in插入，接收不到空格
		while (ch != ' ' && ch != '\n')
		{
			if (i >= 0 && i < 127)
			{
				buff[i++] = ch;

			}
			else if (i == 127)
			{
				buff[127] = '\0';
				s += buff;
				s += ch;
				i = -1;
			}
			else
				s += ch;
			ch = in.get();
		}
		if (i >= 0)
			s += buff;
		return in;
	}

2.8string的插入和删除

	string& insert(size_t pos, const char* str)//在pos插入一个str指向的字符数组，原下标pos
	{                                         //以及之后的元素向后移位
		assert(pos <= _size);//插入位置是否越界
		int len = strlen(str);
		int i = _size + len;
		_str[i] = '\0';
		i--;
		if (_size + len > _capacity)
			reserve(_capacity + len);
		while (i >= pos + len)//类型转换
		{
			_str[i] = _str[i - len];
			i--;
		}
		i = strlen(str);
		while (i > 0)
		{
			_str[pos + i - 1] = str[i - 1];
			i--;
		}
		_size += len;
		return *this;
	}
	string& insert(size_t pos,int size ,const char ch)//在pos插入目标字符，原下 
                                                       //标pos以及之后的元素向后移位
	{
		assert(pos <= _size);//插入位置是否越界
		int i = _size + 1;
		if (_size + 1 > _capacity)
			reserve(_capacity *1.5);
		while (i >= pos + 1)//类型转换
		{
			_str[i] = _str[i - 1];
			i--;
		}
			_str[pos] =ch;
			i--;
		_size += 1;
		return *this;
	}
	string& erase(size_t pos, size_t len = npos)//npos是-1的无符号数强转，即42亿多，一个字符数组不会这末长，
	{                                         //结果就是把pos及后面的内容都删了。
		if (pos + len > _size || len == npos)//从下标pos出开始删除，一直删除狗len个元素或删完。
		{
			_size = pos;
			_str[_size] = '\0';
		}
		else
		{
			strcpy(_str + pos, _str + pos + len);
			_size -= len;
		}
		return *this;
	}

2.9vs和g++下string结构的说明

注意：下述结构是在 32 位平台下进行验证， 32 位平台下指针占 4 个字节。

2.9.1vs下string的结构

string 总共占 28 个字节 ，内部结构稍微复杂一点，先是 有一个联合体，联合体用来定义 string 中字

符串的存储空间 ：

当字符串长度小于 16 时，使用内部固定的字符数组来存放

当字符串长度大于等于 16 时，从堆上开辟空间

union _Bxty
{ // storage for small buffer or pointer to larger one
 value_type _Buf[_BUF_SIZE];
 pointer _Ptr;
 char _Alias[_BUF_SIZE]; // to permit aliasing
} _Bx;

这种设计也是有一定道理的，大多数情况下字符串的长度都小于 16 ，那 string 对象创建好之后，内

部已经有了 16 个字符数组的固定空间，不需要通过堆创建，效率高。

其次：还有一个 size_t 字段保存字符串长度，一个 size_t 字段保存从堆上开辟空间总的容量

最后：还 有一个指针 做一些其他事情。

故总共占 16+4+4+4=28 个字节。

2.9.2g++下string的结构

G++ 下， string 是通过写时拷贝实现的， string 对象总共占 4 个字节，内部只包含了一个指针，该指

针将来指向一块堆空间，内部包含了如下字段：

空间总大小
字符串有效长度
引用计数

3. string类的模拟实现

3.1统版写法的String类

class String
{
public:
 String(const char* str = "")
 {
 // 构造String类对象时，如果传递nullptr指针，可以认为程序非
 if (nullptr == str)
 {
 assert(false);
 return;
 }
 _str = new char[strlen(str) + 1];
 strcpy(_str, str);
 }
 String(const String& s)
 : _str(new char[strlen(s._str) + 1])
 {
 strcpy(_str, s._str);
 }
 String& operator=(const String& s)
 {
 if (this != &s)
 {
 char* pStr = new char[strlen(s._str) + 1];
 strcpy(pStr, s._str);
 delete[] _str;
 _str = pStr;
 }
 return *this;
 }
~String()
 {
 if (_str)
 {
 delete[] _str;
 _str = nullptr;
 }
 }
private:
 char* _str;
};

3.2 现代版写法的String类

class String
{
public:
 String(const char* str = "")
 {
 if (nullptr == str)
 {
 assert(false);
 return;
 }
 _str = new char[strlen(str) + 1];
 strcpy(_str, str);
 }
 String(const String& s)
 : _str(nullptr)
 {
 String strTmp(s._str);
 swap(_str, strTmp._str);
 }
 // 对比下和上面的赋值那个实现比较好？
 String& operator=(String s)
 {
 swap(_str, s._str);
 return *this;
 }
 /*
 String& operator=(const String& s)
 {
 if(this != &s)
 {
 String strTmp(s);
 swap(_str, strTmp._str);
 }
return *this;
 }
 */
 ~String()
 {
 if (_str)
 {
 delete[] _str;
 _str = nullptr;
 }
 }
private:
 char* _str;
};

总结：

事实上，string一共有100多个接口，但是有很多我们很少用到，今天所讲的也是较为常见的、使用频率较高的接口，如果以后什么时候有对别的接口的需求可以去文档里查看。

ok，那么，string，over！

一颗青果

关注

40
点赞
踩
15

收藏

觉得还不错? 一键收藏
5
评论
string类详解及重要函数实现

咱们之前也是打开了c++的大门，相信很多朋友对这门新的语言都充满了好奇，那么今天就来份硬菜满足一下各位，铛铛铛铛，c++第二座大山：STL之string，他来了！【本节目标】1.为什么要学习string类2.标准库中的string类3. string类的模拟实现1.为什么学习string类？1.1 C语言中的字符串C语言中，字符串是以'\0'结尾的一些字符的集合，为了操作方便，C标准库中提供了一些str系列的库函数，但是这些库函数与字符串是分离开的，不太符合。
复制链接

扫一扫