【C++】手撕string类（超实用！）

news2024/11/15 19:47:17

前言

一、标准库中的string类

1.1 string类介绍

1.2 string的常用接口

1.2.1 常用的构造函数

1.2.2 容量操作接口

（1）size

（2）capacity 

（3）empty 

（4）clear 

（5）reserve 

（6）resize 

1.2.3 访问和遍历

（1）operator[] 

（2）迭代器 

（3）at 

（4）back

（5）front

（6）find

（7）rfind和npos

（8）c_str

1.2.4 修改字符串操作

（1）operator+=

（2）push_back

（3）append

（4）insert

（5）erase

（6）swap

（7）operator+

（8）getline

1.2.5 各种运算符重载函数

（1）operator>>和operator<<

（2）比较运算符

二、模拟实现string类

前言

学习string类之前，我们需要对STL库有一个简单的了解

STL（standard template library——标准模板库），是C++标准库的重要组成部分，不仅是一个可复用的组件库，还是一个包罗数据结构与算法的软件框架。

STL有六大组件：

一、标准库中的string类

1.1 string类介绍

string类是表示字符串的一个类，内部通常有三个成员变量：指向字符串的指针、字符串的有效元素个数和字符串的容量大小

char* _str;
size_t _size;
size_t _capacity;

我们通过string类中的成员函数（接口），就能对字符串进行各种操作

在使用string类时，必须包含头文件<string>和using namespace std;

1.2 string的常用接口

1.2.1 常用的构造函数

string();

默认构造函数，用于构造空的string类对象

例如：

void Test()
{
    string s1;
}
string(const char* s);

用一个常量字符串来构造string类对象

例如：

void Test()
{
    string s1("hello");
}
string(const string& s);

string类的拷贝构造函数

例如：

void Test()
{
    string s1("hello");
    string s2(s1);
}

1.2.2 容量操作接口

（1）size

size_t size() const;

返回字符串有效字符长度

string类中还有一个函数length和size的效果一样，最初只有length存在，为了和其他容器相同后面新增了size

例如：

（2）capacity 

size_t capacity() const;

返回字符串容量

例如：

（3）empty 

bool empty()  const;

 检测字符串是否为空串，为空返回true，否则返回false

例如：

（4）clear 

void clear();

用于清空有效字符，不改变字符串容量大小

例如：

（5）reserve 

void reserve(size_t n = 0);

为字符串预留空间

例如：

如果n比原容量小则不作改变

在vs上常常会开比n更大一些的空间

（6）resize 

void resize(size_t n);

void resize(size_t n, char c);

将有效字符的个数修改为n，并且如果n大于原来的_size，多出来的地方用字符c填充，不改变字符串容量大小

如果没有给出字符c，则用\0填充

例如：

1.2.3 访问和遍历

（1）operator[] 

char& operator[](size_t pos);

const char& operator[](size_t pos) const;

返回字符串中pos位置的字符

例如：

（2）迭代器 

iterator begin();

const_iterator begin() const;

iterator end();

const_iterator end() const;

迭代器，用于获取字符串第一个字符的位置和最后一个字符的下一个位置

例如：

reverse_iterator rbegin();

const_reverse_iterator rbegin() const;

reverse_iterator rend();

const_reverse_iterator rend() const;

反向迭代器，rbegin获取字符串最后一个字符的下一个位置，rend获取字符串的第一个位置

例如：

需要注意，这里rit是加加而不是减减

范围for的底层实际上也是迭代器

（3）at 

char& at(size_t pos);

const char& at(size_t pos) const;

返回字符串中pos位置的字符的引用

例如：

（4）back

char& back();

const char& back() const;

返回字符串最后一个字符的引用

例如：

（5）front

char& front();

const char& front() const;

返回字符第一个字符串的引用

例如：

（6）find

size_t find(char c, size_t pos = 0) const;

从字符串的pos位置向后找字符c，返回该字符在字符串中的位置

例如：

（7）rfind和npos

size_t rfind(char c, size_t pos = npos) const;

static const size_t nops = -1

从字符串的pos位置向前找字符c，返回该字符在字符串中的位置

npos是string类中定义的一个静态成员变量，类型为无符号整型，值为-1，因为是无符号转换后变成整型的最大值，也就是4294967295（42亿多），当我们不给pos的值时按照缺省值执行，默认从字符串尾部开始找起

例如：

（8）c_str

const char* c_str() const;

按照C语言的格式返回字符串

例如：

在hello后面加上\0和字符串world，重载后的流插入操作符函数会按照size的大小来打印字符串

而打印c_str的返回值，会遇到\0就停下

1.2.4 修改字符串操作

（1）operator+=

string& operator+=(const string& str);

string& operator+=(const char* s);

string& operator+=(char c);

在字符串后追加一个字符串或字符

例如：

（2）push_back

void push_back(char c);

在字符串后尾插一个字符c

例如：

（3）append

string& append(const string& str);

string& append(const char* s);

string& append(const char* s, size_t n);

string& append(size_t n, char c);

用于在字符串后加一个字符串、一个字符串的前n个字符或n个字符c

例如：

（4）insert

string& insert(size_t pos, const string& str);

string& insert(size_t pos, const char* s);

string& insert(size_t pos, const char* s, size_t n);

string& insert(size_t pos, size_t n, char c);

iterator insert(iterator p, char c);

用于在字符串的pos位置插入一个字符串、字符串的前n个字符或n个字符c

还有迭代器版本的insert，用法是在p的位置插入字符c 

例如：

（5）erase

string& erase(size_t pos, size_t len = npos);

iterator erase(iterator p);

iterator erase(iterator first, iterator last);

用于在字符串的pos位置删除len个字符

迭代器版本的erase，在p的位置删除一个字符，或者删除 [ first , last ) 内的字符

例如：

（6）swap

void swap(string& str);

用于交换两个string类对象

string类中的swap函数相比标准库中的swap函数，交换string类对象的效率更高

例如：

（7）operator+

string operator+(const string& lhs, const string& rhs);

string operator+(const string& lhs, const char* rhs);

string operator+(const char* lhs, const string& rhs);

string operator+(const string& lhs, char rhs);

string operator+(char lhs, const string& rhs);

返回一个新构造的string类对象，其值是lhs和rhs的合并

例如：

（8）getline

istream& getline(istream& is, string& str, char delim);

istream& getline(istream& is, string& str);

用于字符串的输入

相比cin遇到空格就停止提取，我们可以给出分隔符delim，遇到delim才停止提取，如果没有给出，则遇到换行停止提取

例如：

 

1.2.5 各种运算符重载函数

（1）operator>>和operator<<

istream& operator>>(istream& is, string& str);

ostream& operator<<(ostream& os, const string& str);

用于string对象的流提取和流插入

例如：

（2）比较运算符

各种比较运算符的重载函数，这里就不赘述了

用于比较两个字符串的对应位置的ASCII码值大小

例如：

二、模拟实现string类

知道了string类中各种常用接口的用法后，我们就可以开始自己手撕一个自己的string类了

为了不和标准库中的string类冲突，我们可以开一个自己的命名空间

完整代码如下：

namespace Eristic
{
	class string
	{
		friend ostream& operator<<(ostream& cout, const string& s);
		friend istream& operator>>(istream& cout, const string& s);
	public:
		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;
		}

		string(const char* str = "")
			:_size(strlen(str))
		{
			_capacity = _size == 0 ? 3 : _size;
			_str = new char[_capacity + 1];
			strcpy(_str, str);
		}

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

		bool empty() const
		{
			size_t len = strlen(_str);
			return !len;
		}

		char& at(size_t pos)
		{
			assert(pos < _size);
			return _str[pos];
		}

		const char& at(size_t pos) const
		{
			assert(pos < _size);
			return _str[pos];
		}

		char& back()
		{
			return at(_size - 1);
		}

		const char& back() const
		{
			return at(_size - 1);
		}

		char& front()
		{
			return at(0);
		}

		const char& front() const
		{
			return at(0);
		}

		void resize(size_t n, char ch = '\0')
		{
			if (n < _size)
			{
				_size = n;
				_str[_size] = '\0';
			}
			else if (n > _size)
			{
				if (n > _capacity)
				{
					reserve(n);
				}
				for (size_t i = _size; i < n; i++)
				{
					_str[i] = ch;
				}
				_size = n;
				_str[_size] = '\0';
			}
		}

		void push_back(char ch)
		{
			if (_size + 2 > _capacity)
			{
				reserve(_capacity * 2);
			}
			_str[_size] = ch;
			_size++;
			_str[_size] = '\0';
			//insert(_size, ch); //或者直接复用
		}

		void push_back(const char* str)
		{
			append(str);
		}

		void append(const char* str)
		{
			int len = strlen(str);
			if (_size + len > _capacity)
			{
				reserve(_size + len);
			}
			strcpy(_str + _size, str);
			_size += len;
		}

		string& insert(size_t pos, char ch)
		{
			assert(pos <= _size);
			if (_size + 1 > _capacity)
			{
				reserve(_capacity * 2);
			}
			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 (_size + len > _capacity)
			{
				reserve(_size + len);
			}
			size_t end = _size + len;
			while (end > pos + len - 1)
			{
				_str[end] = _str[end - len];
				--end;
			}
			strncpy(_str + pos, str, len);
			_size += len;
			return *this;
		}

		string& erase(size_t pos, size_t len = npos)
		{
			assert(pos < _size);
			if (len >= _size - pos)
			{
				_str[pos] = '\0';
			}
			else
			{
				strcpy(_str + pos, _str + pos + len);
			}
			_size -= len;
			return *this;
		}

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

		void clear()
		{
			_str[0] = '\0';
			_size = 0;
		}

		size_t find(char ch, size_t pos = 0) const
		{
			assert(pos < _size);
			for (size_t i = pos; i < _size; ++i)
			{
				if (_str[i] == ch)
				{
					return i;
				}
			}
			return npos;
		}

		size_t find(const string& s, size_t pos = 0) const
		{
			assert(pos < _size);
			char* p = strstr(_str + pos, s._str);
			if (p == nullptr)
			{
				return npos;
			}
			return p - _str;
		}

		size_t find(const char* str, size_t pos = 0) const
		{
			assert(pos < _size);
			char* p = strstr(_str + pos, str);
			if (p == nullptr)
			{
				return npos;
			}
			return p - _str;
		}

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

		string& operator+=(const string& s)
		{
			push_back(s._str);
			return *this;
		}

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

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

		const char& operator[](size_t pos) const
		{
			assert(pos < _size);
			return _str[pos];
		}

		char& operator[](size_t pos)
		{
			assert(pos < _size);
			return _str[pos];
		}

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

		size_t size() const
		{
			return _size;
		}

		size_t capacity() const
		{
			return _capacity;
		}

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

		~string()
		{
			delete[] _str;
			_capacity = _size = 0;
		}

	private:
		char* _str;
		size_t _size;
		size_t _capacity;

		static const size_t npos;
	};

	const size_t string::npos = -1;

	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 buff[128];
		size_t i = 0;
		while (ch != ' ' && ch != '\n')
		{
			buff[i++] = ch;
			if (i == 127)
			{
				buff[i] = '\0';
				s += buff;
				i = 0;
			}
			ch = in.get();
		}
		if (i != 0)
		{
			buff[i] = '\0';
			s += buff;
		}
		return in;
	}
}

如有错误，欢迎在评论区指出

完.

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/1502520.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

10部程序员必看的纪录片

10部程序员必看的纪录片

从本文介绍的影片中可以看到各式各样的程序员&#xff1a;他们有的才华横溢&#xff0c;14岁就创造了RSS1.0规格&#xff0c;足迹遍及整个互联网&#xff0c;但英年早逝&#xff1b;有的活在自己世界并坚守着自己的理想&#xff0c;想法不为他人而决定&#xff1b;有的在尽自己…
阅读更多...
vue3 （四）动态组件Vs异步组件

vue3 （四）动态组件Vs异步组件

1.动态组件 点击toggle切换2个组件&#xff0c;配合<keep-alive>使用防止切换后数据丢失 <keep-alive><component :is"currentItem"></component> </keep-alive> 2.异步组件 定义方法&#xff1a;app.component(组件名,Vue.defineAs…
阅读更多...
html--心动

html--心动

代码 <!DOCTYPE html> <html lang"en"> <head><meta charset"UTF-8"><title>html</title><style>*{padding: 0;margin: 0;}body{background-color: pink;}#frame{position: relative;width: 400px;height: 300…
阅读更多...
请编程输出无向无权图各个顶点的度 ← 链式前向星存图

请编程输出无向无权图各个顶点的度 ← 链式前向星存图

【题目描述】请利用链式前向星存图&#xff0c;编程输出无向无权图各个顶点的度。【输入样例】 5 6 1 3 2 1 1 4 2 3 3 4 5 1【输出样例】 4 2 3 2 1【算法分析】 本例需要用到基于链式前向星的广度优先搜索&#xff08;BFS&#xff09;。 链式前向星广度优先搜索&#xff08;B…
阅读更多...
Springboot+vue的项目申报管理系统（有报告）。Javaee项目，springboot vue前后端分离项目。

Springboot+vue的项目申报管理系统（有报告）。Javaee项目，springboot vue前后端分离项目。

演示视频&#xff1a; Springbootvue的项目申报管理系统&#xff08;有报告&#xff09;。Javaee项目&#xff0c;springboot vue前后端分离项目。 项目介绍&#xff1a; 采用M&#xff08;model&#xff09;V&#xff08;view&#xff09;C&#xff08;controller&#xff09…
阅读更多...
PCM会重塑汽车OTA格局吗(1)

PCM会重塑汽车OTA格局吗(1)

目录 1.汽车OTA概述 2.ST如何考虑OTA&#xff1f; 2.1 Stellar四大亮点 2.2 PCM技术视角下的OTA 3.小结 1.汽车OTA概述 随着智能网联汽车的飞速发展&#xff0c;汽车OTA也越来越盛行&#xff1b; 目前来讲OTA分为FOTA和SOTA(Software-over-the-air)两种&#xff0c;区别…
阅读更多...
强大的项目管理软件：OmniPlan Pro 4 mac中文版

强大的项目管理软件：OmniPlan Pro 4 mac中文版

OmniPlan Pro 4 mac中文版是由The Omni Group为macOS和iOS操作系统开发的一款专业级项目管理软件。它允许用户创建和管理复杂的项目&#xff0c;从定义任务、分配资源到跟踪进度和生成报告&#xff0c;一应俱全。 这款软件提供了一系列强大的工具&#xff0c;帮助用户进行高效…
阅读更多...
MATLAB中积分域内部的奇点

MATLAB中积分域内部的奇点

目录 将被积函数定义为匿名函数 对方形求积分 将积分域拆分为两个三角形 本示例显示如何拆分积分域以将奇点放在边界上。 将被积函数定义为匿名函数 复值积分的被积函数 在 x y 0 时有一个奇点&#xff0c;并通常是 y -x 线上的奇异值。 将该被积函数定义为匿名函数。 …
阅读更多...
【Android 内存优化】KOOM 快手开源框架线上内存监控方案-源码剖析

【Android 内存优化】KOOM 快手开源框架线上内存监控方案-源码剖析

文章目录 前言OOMMonitorInitTask.INSTANCE.initOOMMonitor.INSTANCE.startLoopsuper.startLoopcall() LoopState.Terminate dumpAndAnalysisdumpstartAnalysisService回到startLoop方法总结 前言 这篇文章主要剖析KOOM的Java层源码设计逻辑。 使用篇请看上一篇: 【Android …
阅读更多...
LCR 132. 砍竹子 II

LCR 132. 砍竹子 II

解题思路&#xff1a; 由于数量级较大&#xff0c;需要使用long以及快速幂求余 下图便于理解快速幂求余 class Solution {public int cuttingBamboo(int bamboo_len) {if(bamboo_len < 3) return bamboo_len - 1;int b bamboo_len % 3, p 1000000007;long rem 1, x 3;f…
阅读更多...
计算机网络——23网络层导论

计算机网络——23网络层导论

网络层导论 网络层服务 在发送主机和接收主机对之间传送段&#xff08;segment&#xff09;在发送端将段封装到数据报中在接收端&#xff0c;将段上交给传输层实体网络层协议存在于每一个主机和路由器路由器检查每一个经过它的IP数据报的头部 网络层的关键功能 网络层功能 …
阅读更多...
【重温设计模式】备忘录模式及其Java示例

【重温设计模式】备忘录模式及其Java示例

备忘录模式的概述 在软件设计的世界中&#xff0c;备忘录模式是一种行为设计模式&#xff0c;它的主要作用是保存对象的当前状态&#xff0c;以便在将来的某个时间点&#xff0c;可以将对象恢复到这个保存的状态。这种模式的命名源于生活中的备忘录&#xff0c;我们常常用它来…
阅读更多...
图机器学习（4）-面向连接层面的人工特征工程

图机器学习（4）-面向连接层面的人工特征工程

0 问题定义 通过已经连接去猜未知连接&#xff1a; 有两个思路&#xff1a; &#xff08;1&#xff09;直接提取link的特征&#xff0c;把link变成D维向量&#xff1b; &#xff08;2&#xff09;把link两端节点的D维向量拼在一起&#xff0c;缺点&#xff1a;丢失了link本身…
阅读更多...
JavaScript极速入门-综合案例(3)

JavaScript极速入门-综合案例(3)

综合案例 猜数字 预期效果 代码实现 <button type"button" id"reset">重新开始一局游戏</button><br>请输入要猜的数字:<input type"text" id"number"><button type"button" id"button&q…
阅读更多...
php使用ElasticSearch

php使用ElasticSearch

ElasticSearch简介 Elasticsearch 是一个分布式的、开源的搜索分析引擎&#xff0c;支持各种数据类型&#xff0c;包括文本、数字、地理、结构化、非结构化。 Lucene与ElasticSearch Apache Lucene是一款高性能的、可扩展的信息检索&#xff08;IR&#xff09;工具库&#xf…
阅读更多...
算法学习06：数组模拟：单/双链表，栈和队列，单调栈/队列

算法学习06：数组模拟：单/双链表，栈和队列，单调栈/队列

算法学习06&#xff1a;数组模拟&#xff1a;单/双链表&#xff0c;栈和队列&#xff0c;单调栈/队列 文章目录 算法学习06&#xff1a;数组模拟&#xff1a;单/双链表&#xff0c;栈和队列&#xff0c;单调栈/队列前言一、链表1.单链表2.双链表 二、栈和队列1.普通栈、队列2.单…
阅读更多...
[LeetCode][102]二叉树的层序遍历——遍历结果中每一层明显区分

[LeetCode][102]二叉树的层序遍历——遍历结果中每一层明显区分

题目 102. 二叉树的层序遍历 给定二叉树的根节点 root&#xff0c;返回节点值的层序遍历结果。即逐层地&#xff0c;从左到右访问所有节点。 示例 1&#xff1a; 输入&#xff1a;root [3,9,20,null,null,15,7] 输出&#xff1a;[[3],[9,20],[15,7]] 示例 2&#xff1a; 输入…
阅读更多...
【计算机网络】TCP 的三次握手与四次挥手

【计算机网络】TCP 的三次握手与四次挥手

通常我们进行 HTTP 连接网络的时候会进行 TCP 的三次握手&#xff0c;然后传输数据&#xff0c;之后再释放连接。 TCP 传输如图1所示&#xff1a; 图1 TCP 传输 TCP三次握手的过程如下&#xff1a; 第一次握手&#xff1a;建立连接。客户端发送连接请求报文段&#xff0c;将 …
阅读更多...
深度学习模型部署(四)常用模型及推理平台评估指标

深度学习模型部署(四)常用模型及推理平台评估指标

判断选择什么模型&#xff0c;什么量化方案&#xff0c;什么推理框架&#xff0c;最基础的知识就是如何评估自己的模型以及推理平台。 模型衡量标准 衡量一个模型的最直接标准就是运算速度&#xff0c;但是运算速度是无法计算的&#xff0c;所以定义了一些间接标准来推测模型的…
阅读更多...
探索数据可视化：Matplotlib 基础指南

探索数据可视化：Matplotlib 基础指南

图形绘制 import numpy as np import pandas as pd import matplotlib.pyplot as pltx np.linspace(0,2 * np.pi,100)# 说明&#xff1a;正弦波。x&#xff1a;NumPy数组 # 所有的数据&#xff0c;进行正弦计算 y np.sin(x)plt.plot(x,y)# 指定x轴范围 plt.xlim(-1,10) # 指…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023