C++中String的语法及常用接口的底层实现详解

这篇具有很好参考价值的文章主要介绍了C++中String的语法及常用接口的底层实现详解。希望对大家有所帮助。如果存在错误或未考虑完全的地方,请大家不吝赐教,您也可以点击"举报违法"按钮提交疑问。

  在C语言中,我们知道处理字符串所用的类型是 char []或者char* 。字符串是以‘\0’结尾的。在C++中,string 是一个标准库类(class),用于处理字符串。它提供了一种更高级、更便捷的字符串操作方式,string 类提供了一系列成员函数和重载运算符,以便于对字符串进行操作和处理。本编文章会对C++中的 string 进行详解,希望本篇文章会对你有所帮助。

目录

一、string类

二、string的常用见用法

2、1 string对象的构造

2、1、1 string对象的构造的使用方法

2、1、2 string()的底层实现

2、1、3 string(const char* s)的底层实现

2、2 string对象的修改操作

2、3 string对象的容量操作

2、4 string对象的访问和遍历操作

三、string常用结构的底层实现

3、1 初建结构

3、2 返回大小和容量

3、3 拷贝构造和赋值重载

3、4 扩容(reserve)

3、5 插入(push_back、append、operator+=、insert)

3、6 删除(erase)

3、7 查找(find)

3、8 返回子串(substr)

3、9 迭代器(iterator)

3、10 比较(>、<、>=、<=、==、!=)

四、总结


🙋‍♂️ 作者:@Ggggggtm 🙋‍♂️

👀 专栏:C++  👀

💥 标题:String讲解💥

 ❣️ 寄语:与其忙着诉苦,不如低头赶路,奋路前行,终将遇到一番好风景 ❣️  

C++中String的语法及常用接口的底层实现详解

一、string类

  在学习 string 前,我们不妨先来了解一下 string 类到底是什么,有什么用呢?下图是C++标准库中的对 string 内容:

C++中String的语法及常用接口的底层实现详解

  what???没错,C++标准库都是英语解释。我们也应该试着去适应,不懂的可以查阅。当然,在这里我就直接给出翻译,主要是以下内容:

  1. 字符串是表示字符序列的类;
  2. 标准的字符串类提供了对此类对象的支持,其接口类似于标准字符容器的接口,但添加了专门用于操作单字节字符字符串的设计特性。
  3. string类是使用char(即作为它的字符类型,使用它的默认char_traits和分配器类型(关于模板的更多信息,请参阅basic_string)。
  4. string类是basic_string模板类的一个实例,它使用char来实例化basic_string模板类,并用char_traits和allocator作为basic_string的默认参数(根于更多的模板信息请参考basic_string)。
  5. 注意,这个类独立于所使用的编码来处理字节:如果用来处理多字节或变长字符(如UTF-8)的序列,这个类的所有成员(如长度或大小)以及它的迭代器,将仍然按照字节(而不是实际编码的字符)来操作。

  了解到上面的内容后,我们要开始真正的学习 string 的用法了。

二、string的常用见用法

2、1 string对象的构造

2、1、1 string对象的构造的使用方法

  最为常用的无非就是我们用串string来构造一个对象,也就是存储一个字符,常用的方法有如下几点:

  • string()——构造空的 string 类对象,即空字符串;
  • string(const char* s)——用 char* 来构造 string 类对象;
  • string(size_t n, char c)——string类对象中包含n个字符c
  • string(const string&s)——拷贝构造函数

  下面是使用方法所对应的实例,帮助更好的理解其用法。

C++中String的语法及常用接口的底层实现详解

  根据上面的实例和对应的输出结果,我们可以更好的理解。 

2、1、2 string()的底层实现

  构造空串,其有效字符长度为0,但是实际上是开辟了一个字节的空间存储 ‘\0’ 的。具体如下:

	string()
		:_str(new char[1])
		, _size(0)
		,_capacity(0)
	{
	}

2、1、3 string(const char* s)的底层实现

  我们这里就给出以上两个底层的构造实现,其余两个类似,就不再给出。具体实现如下:

string(const char* str = "") //默认空串。注意:空串是以 \0 结尾
		{
			_size = strlen(str);
			_capacity = _size;
			_str = new char[_size + 1];
			strcpy(_str, str);
		}

2、2 string对象的修改操作

  当我们构建好对象后,我们接下来就要往对应的字符串对象进行修改操作了。常用的修改操作无非就是插入和查找,具体有如下几种常见用法:

  • push_back——在字符串后尾插字符c
  • insert——在pos位置插入n个字符或者插入一个字符串;
  • append ——在字符串后追加一个字符串
  • operator+=——在字符串后追加字符或者字符串str;
  • c_str——返回C格式字符串;
  • find——从字符串pos位置开始往后找字符c,返回该字符在字符串中的位置。

  我们再看其具体的使用方法实例,如下图:

C++中String的语法及常用接口的底层实现详解

  上图为常用的修改用法。当然,其他的用法还有很多。如果想了解的过可去C++官网(cppreference)或者 cplusplus 的标准库中查询。具体也可看下图:

  insert

C++中String的语法及常用接口的底层实现详解

  operator+= C++中String的语法及常用接口的底层实现详解

  find C++中String的语法及常用接口的底层实现详解

2、3 string对象的容量操作

  在平常对字符串的操作中,我们也经常需要去了解到字符串的实际长度为多少,或者改数组到底能够存下多长的字符串,又或是修改字符串的长度和空间大小。C++的string类中,这些操作都提供了相应的接口,具体如下:

  • size——返回字符串有效字符长度;
  • length——返回字符串有效字符长度
  • empty——检测字符串释放为空串,是返回true,否则返回false;
  • reserve——为字符串预留空间;
  • resize——将有效字符的个数该成n个,多出的空间用字符c填充;
  • capacity——返回空间总大小;
  • clear——清空有效字符;

  我们发现。size和length的功能一样的。确实都是求字符串的有效长度。那我们接着看其具体的实例:

C++中String的语法及常用接口的底层实现详解  注意:capacity返回的是空间的总大小size和length返回的是字符串的实际有效长度。 两者是有所区别的。一个字符串的capacity是有底层的具体实现决定的,不同的编译器可能实现的是不同的。

2、4 string对象的访问和遍历操作

  string对象的访问,支持像数组一样使用 [] 进行访问,也可通过迭代器进行访问,具体有如下用法:

  • operator[]——返回pos位置的字符,const string类对象调用;
  • begin+ end——begin获取一个字符的迭代器 + end获取最后一个字符下一个位置的迭
    代器;
  • 范围for——C++11支持更简洁的范围for的新遍历方式。

   其具体的用法实例如下:

C++中String的语法及常用接口的底层实现详解

  范围for的底层实现就是用迭代器来实现的。写起来更加的便捷和方便。 

  以上为string中较为常用的接口。以上完全足够我们平常的使用了,如果想要了解的更多,可参考C++的标准库。不过string容器一共实现了106个接口!!!其中大部分都是冗余的。这也是很多人吐槽string类实现的过于复杂和冗余的一个重要原因。所以在查看时,我们只需要看自己想要了解的接口即可。 

三、string常用结构的底层实现

3、1 初建结构

  我们通过上述的构造,不难发现也不难理解string的底层其实就是一个字符指针,该指针指向一个数组。当然,我们还需要两个变量来维护其有效长度(_size)数组容量(_capacity)

  其次,我们自己实现的string类为了区分std命名空间,我们可自己设置一个命名空间。处型的模拟实现如下:

namespace gtm
{

	class string
	{
     public:
        //string()
		//	:_str(new char[1])
		//	, _size(0)
		//	,_capacity(0)
		//{
		//}

		//string(const char* str)
		//	:_str(new char[strlen(str) + 1])  //三次strlen函数,效率低。
		//	,_size(strlen(str))
		//	,_capacity(strlen(str))
		//{
		//	strcpy(_str, str);
		//}

		// 不再使用strlen函数,初始化列表与变量声明顺序固定
		string(const char* str = "") //默认空串。注意:空串是以 \0 结尾
		{
			_size = strlen(str);
			_capacity = _size;
			_str = new char[_size + 1];
			strcpy(_str, str);
		}
        ~string()
		{
			delete[] _str;
			_str = nullptr;
			_size = _capacity = 0;
		}
     private:
		char* _str;
		size_t _size;
		size_t _capacity;
	};

  注意,我们上述省略了无参的构造。原因是我们在字符串的构造中有缺省参数,即为空串。

3、2 返回大小和容量

  这两个部分,是比较容易实现的两部分。同时也是较为常用的两部分。具体如下:

		size_t size() const
		{
			return _size;
		}

		size_t capacity() const
		{
			return _capacity;
		}

3、3 拷贝构造和赋值重载

  这两部分较为复杂的两部分。其中均需要深拷贝去实现完成,而浅拷贝是不可以的。注意:拷贝构造使用一个已定义变量去初始化另一个变量,赋值重载是两个已定义变量进行赋值

具体实现如下:

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

		void swap(string& tmp)
		{
			//调用全局的swap
			::swap(_str, tmp._str);
			::swap(_size, tmp._size);
			::swap(_capacity, tmp._capacity);
		}

		//借助变量tmp
		string(const string& s)
			:_str(nullptr) 
			, _size(0)
			, _capacity(0)
		{
			string tmp(s._str);
			swap(tmp);
		}

		//赋值
		//string& operator=(const string& s)
		//{
		//	if(this == &s)
		//	{
		//		return *this;
		//	}
		//	//先开空间拷贝数据,以防new失败销毁原来的空间
		//	char* tmp = new char[s._capacity + 1];
		//	strcpy(tmp, s._str);

		//	delete[] _str;
		//	_str = tmp;
		//	_size = s._size;
		//	_capacity = s._capacity;
		//	return *this;


		//	//delete[] _str;
		//	//_str = new char[s._capacity + 1];
		//	//strcpy(_str, s._str);
		//	//_size = s._size;
		//	//_capacity = s._capacity;
		//	return *this;
		//}

		//string& operator=(const string& s)
		//{
		//	if(this == &s)
		//	{
		//		return *this;
		//	}
		//	string tmp(s._str);
		//	swap(tmp);
		//  return *this;
		//}

		string& operator=(string s)
		{
			if (this == &s)
			{
				return *this;
			}
			swap(s);
			return *this;
		}

   上述的辅助重载我们巧妙地借助了临时变量s。当赋值完成后,出了作用域s会自动调用戏后进行销毁,这里是需要反复理解的。

3、4 扩容(reserve)

  我们可简单的理解reserve为扩容(扩容的前提为要求的容量比原来的大),但是我们要记得把字符数组中原有的内容拷贝过来,并且释放之前所动态开辟的空间。 具体实现如下:

		void reserve(size_t capacity)
		{
			if (capacity > _capacity)
			{
				char* tmp = new char[capacity + 1];
				strcpy(tmp, _str);
				delete[] _str;

				_str = tmp;
				_capacity = capacity;
			}
		}

3、5 插入(push_back、append、operator+=、insert)

  插入的实现,主要的点就是是否要进行扩容。其次,当我们实现push_back和append后,其他的均可复用这两个结构进行实现。具体实现如下:

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

			_str[_size] = ch;
			_size++;
			_str[_size] = '\0';
		}

		void append(const char* str)
		{
			size_t len = strlen(str);

			if (len + _size > _capacity)
			{
				reserve(len + _size >= _capacity * 2 ? len + _size : _capacity * 2);
			}

			strcpy(_str + _size, str);
			_size += len;
		}

		void append(const string& s)
		{
			append(s._str);
		}

		void append(int n, char ch)
		{
			reserve(_size + n);
			for (int i = 0; i < n; i++)
			{
				push_back(ch);
			}
		}
		string& operator+= (char ch)
		{
			push_back(ch);

			return *this;
		}

		string& operator+= (const char* str)
		{
			append(str);

			return *this;
		}

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

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

			//注意,当运算数一个是有符号,另一个是无符号时,有符号的运算数会强制类型转换为无符号数。pos等于0的位置插入,end--后为超大数据,会出错。
			//int end = _size;
			//while (end >= (int)pos)
			//{
			//	_str[end + 1] = _str[end];
			//	end--;
			//}

			size_t end = _size+1;
			while (end > pos)
			{
				_str[end] = _str[end - 1];
				end--;
			}

			_str[pos] = ch;
			_size++;

			return *this;
		}

		string& insert(size_t pos, const char* str)
		{
			assert(pos <= _size);

			size_t len = strlen(str);

			if (len + _size > _capacity)
			{
				reserve(len + _size >= _capacity * 2 ? len + _size : _capacity * 2);
			}


			size_t end = _size + len;
			while (end >= pos+len)
			{
				_str[end] = _str[end - len];
				end--;
			}

			for (int i = pos,j=0; j < len;j++, i++)
			{
				_str[i] = str[j];
			}
			_size += len;
			return *this;
		}

3、6 删除(erase)

  我们这里实现的从某个位置开始删除,删除长度为 len 的字符。len有一个缺省参数,为npos(npos是一个很大的数,也就是不传参给 len 的话,默认删除到最后)。如果 len 本就很大,删除的长度超过从pos开始所剩余的长度,那么默认也是pos后的删除完。那么我们看其具体的实现。

		void erase(size_t pos, size_t len = npos)
		{
			assert(pos < _size);
			if (len == npos || _size - pos <= len)
			{
				_str[pos] = '\0';
				_size = pos;
			}
			else
			{
				strcpy(_str + pos, _str + pos + len);
				_size -= len;
			}
		}

3、7 查找(find)

  查找的话,主要常用的就两个:从pos位置开始查找,查找的内容可能是一个字符,也可能是一个子串。如果找到,则返回其下标。没找到就返回npos。具体实现如下:

		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* sub, size_t pos = 0)const
		{
			const char* ret=strstr(_str + pos, sub);
			if (ret == nullptr)
			{
				return npos;
			}
			else
			{
				return ret - _str;
			}
		}

3、8 返回子串(substr)

  返子串也是我们经常需要的一个接口。返回子串就一个接口,从某个位置开始查找,查找长度为 len 的字符。len有一个缺省参数,为npos(npos是一个很大的数,也就是不传参给 len 的话,默认返回到最后)。如果 len 本就很大,返回子串的长度超过从pos开始所剩余的长度,那么默认也是pos后的子串全部返回。我们看其具体实现:

        string  substr(size_t pos, size_t len = npos)const
		{
			assert(pos < _size);
			size_t realLen = len;
			if (len == npos || pos + len > _size)
			{
				realLen = _size - pos;
			}

			string s;
			for (size_t i = 0; i < realLen; i++)
			{
				s += _str[pos + i];
			}

			return s;
		}

3、9 迭代器(iterator)

  在string中的迭代器底层就是指针,但是并不是所有的迭代器底层实现都是指针!我们直接看起底层实现:

		typedef char* iterator;
		typedef const char* const_iterator;
		iterator begin()
		{
			return _str;
		}
		iterator end()
		{
			return _str + _size;
		}

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

  这里的begin()就是返回的字符串的首元素地址end()返回的是字符串最后一个元素的后一个地址

3、10 比较(>、<、>=、<=、==、!=)

  字符串的比较并非比较其长度,而是与其相同位置字符的大小有关,也就是我们所说的字典序。我们这里只需要实现其中的两个,其他均可复用。具体如下:

		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);
		}

四、总结

  string 在C++中算是比较重要的了,也是入门时必须所学的容器。在平常中使用的频率较高,所以我们不仅要掌握其简单的用法,更应该去了解其底层的实现。这有助于我们后续的使用和理解。本篇文章列举出了string中常用的语法和接口底层的底层实现,这些都是我们应该熟练掌握的内容。

  本篇文章讲解就到这里,感谢观看ovo~文章来源地址https://www.toymoban.com/news/detail-496638.html

到了这里,关于C++中String的语法及常用接口的底层实现详解的文章就介绍完了。如果您还想了解更多内容,请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章,希望大家以后多多支持TOY模板网!

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处: 如若内容造成侵权/违法违规/事实不符,请点击违法举报进行投诉反馈,一经查实,立即删除!

领支付宝红包 赞助服务器费用

相关文章

  • C++ stl容器string的底层模拟实现

    目录 前言: 1.成员变量 2.构造函数与拷贝构造函数 3.析构函数 4.赋值重载 5.[]重载 6.比较关系重载 7.reserve 8.resize 9.push_back,append和重载+= 10.insert 11.erase 12.find 14.迭代器 15.流插入,流提取重载 16.swap 17.c_str 18.完整代码+测试 总结: 1.成员变量 首先注意的就是_str,不能是const类型

    2024年04月23日
    浏览(44)
  • 【C++杂货铺】探索string的底层实现

    string 本质上是一个动态顺序表,它可以根据需要动态的扩容,所以字符串一定是通过在堆上动态申请空间进行存储的,因此 _str 指向存储字符串的空间, _size 用来表示有效字符数, _capacity 用来表示可以存储有效字符的容量数。 注意 :默认构造函数需要注意的地方是:首先

    2024年02月11日
    浏览(44)
  • c++系列之string类的常用接口函数

    💗 💗 博客:小怡同学 💗 💗 个人简介:编程小萌新 💗 💗 如果博客对大家有用的话,请点赞关注再收藏 🌞 string时表示字符串的字符类 //使用 string类包含#include 头文件 以及 using namespace std string容量相关接口 (size(),capacity(),clear(),empty) 1.size()是元素个数 //. size()与length()方

    2024年02月10日
    浏览(37)
  • 【C++】深度剖析string类的底层结构及其模拟实现

    在上两篇中,我们已经学习了string类的一个使用,并且做了一些相关的OJ练习,相信大家现在对于string的使用已经没什么问题了。 那我们这篇文章呢,就来带大家对string进行一个模拟实现,这篇文章过后,有些地方大家或许就可以理解的更深刻一点。 那通过之前文章的学习我

    2023年04月17日
    浏览(106)
  • 【C++ STL】string类最全解析(什么是string?string类的常用接口有哪些?)

    目录 一、前言  二、什么是 string ?  💦 string 类的基本概念 💦 string 类与 char * 的区别   💦 string 类的作用  💦 总结  三、string 的常用接口详解  💦string 类对象的默认成员函数 ① 构造函数(初始化) ② 赋值重载(初始化) 💦string 类对象的访问及遍历操作 ① operator[ ]

    2024年04月17日
    浏览(42)
  • 【C++】:STL中的string类的增删查改的底层模拟实现

    本篇博客仅仅实现存储字符(串)的string 同时由于C++string库设计的不合理,我仅实现一些最常见的增删查改接口 接下来给出的接口都是基于以下框架: C++string标准库中,无参构造并不是空间为0,直接置为空指针 而是开一个字节,并存放‘\\0’ C++中支持无参构造一个对象后,直

    2024年02月05日
    浏览(53)
  • C++初阶:容器适配器介绍、stack和queue常用接口详解及模拟实现

    介绍完了list类的相关内容后:C++初阶:适合新手的手撕list(模拟实现list) 接下来进入新的篇章,stack和queue的介绍以及模拟: stack是一种容器适配器,专门用在具有后进先出操作的上下文环境中,其删除只能从容器的一端进行元素的插入与提取操作。 stack是作为容器适配器

    2024年02月19日
    浏览(44)
  • 【C++入门】string类常用方法(万字详解)

    1.STL简介 1.1什么是STL STL(standard template libaray-标准模板库):是C++标准库的重要组成部分,不仅是一个可复用的组件库,而且是一个包罗数据结构与算法的软件框架 。 1.2STL的版本 原始版本 Alexander Stepanov、Meng Lee 在惠普实验室完成的原始版本,本着开源精神,他们声明允许任何

    2024年02月10日
    浏览(37)
  • [C/C++]string类常用接口介绍及模拟实现string类

            在C语言中,字符串是以\\\'\\0\\\'结尾的一些字符的集合,为了操作方便,C标准库中提供了一些str系列的库函数,但是这些库函数与字符串是分离开的,不太符合OOP的思想,而且底层空间需要用户自己管理,稍不留神可能还会越界访问。 C++中对于string的定义为: typedef ba

    2024年03月22日
    浏览(83)
  • C++ 栈和队列(stack and queue)语法使用及底层实现原理

         本篇文章会对C++中的容器stack和queue用法进行详解,也包含对优先队列(priority_queue)的讲解。同时会模拟实现stack、queue和priority_queue底层。希望本篇文章会对你有所帮助! 目录 一、stack 栈 1、1 什么是适配器 1、2 stack 语法讲解 1、3 stack 底层实现 1、4 deque 双端队列简单

    2024年02月13日
    浏览(38)

觉得文章有用就打赏一下文章作者

支付宝扫一扫打赏

博客赞助

微信扫一扫打赏

请作者喝杯咖啡吧~博客赞助

支付宝扫一扫领取红包,优惠每天领

二维码1

领取红包

二维码2

领红包