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

前言

一、标准库中的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;
	}
}

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

完.

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

如若内容造成侵权/违法违规/事实不符，请联系我们进行投诉反馈qq邮箱809451989@qq.com，一经查实，立即删除！

相关文章

stm32学习记录-5.2PWM输出控制sg90舵机角度

stm32学习记录-5.2PWM输出控制sg90舵机角度

源码连接&#xff1a;https://gitee.com/HL12334/stm32-learning-code 前提知识&#xff1a; 1.定时器中断 1.关键概念 1.1pwm输出 1.常用术语 OC&#xff08;output compare&#xff09;输出比较CNT&#xff08;counter&#xff09;&#xff0c;定时器中用于计数的寄存器…
阅读更多...
【Leetcode每日一刷】数组|双指针篇：977. 有序数组的平方、76. 最小覆盖子串（附滑动窗口法详解）

【Leetcode每日一刷】数组|双指针篇：977. 有序数组的平方、76. 最小覆盖子串（附滑动窗口法详解）

力扣每日刷题 一、977. 有序数组的平方1.1题目1.2、解题思路1.3、代码实现——C 二、76. 最小覆盖子串2.1&#xff1a;题目2.2、解题思路2.3&#xff1a;代码实现——c2.4&#xff1a;易错点 一、977. 有序数组的平方 1.1题目 [题目链接]( 1.2、解题思路 题型&#xff1a;双…
阅读更多...
数据中台驱动：高效交付之道

数据中台驱动：高效交付之道

如何保证数据中台高效交付&#xff1f; 在数据行业中&#xff0c;项目交付难题尤为突出&#xff0c;尤其在数据中台领域。数据中台项目交付面临诸多挑战&#xff0c;若不妥善解决&#xff0c;将会降低服务质量&#xff0c;影响企业数字化建设的顺利开展&#xff0c;甚至影响项目…
阅读更多...
21 卷积层里的多输入多输出通道【李沐动手学深度学习v2课程笔记】

21 卷积层里的多输入多输出通道【李沐动手学深度学习v2课程笔记】

目录 1. 多输入输出通道&相应代码实现 1.1 多输入 1.2 多输出 1.3 1x1 卷积层 1.4 小结 1. 多输入输出通道&相应代码实现 1.1 多输入 为了加深理解&#xff0c;我们实现一下多输入通道互相关运算。 简而言之&#xff0c;我们所做的就是对每个通道执行互相关操作&a…
阅读更多...
电磁兼容（EMC）：一文读懂压敏电阻选型

电磁兼容（EMC）：一文读懂压敏电阻选型

目录 1 MOV 外观结构 2 MOV 常见品牌 3 MOV命名规则 4 MOV 工作原理 5 MOV基本特点 6 MOV典型应用 7 MOV电气参数说明 8 MOV 选型注意事项 8.1 压敏电压V1mA 8.2 峰值脉冲电流 IP&#xff0c;钳位电压VC 8.3 漏电流IR 8.4 结电容 9 有绝缘耐压测试要求时选型 10 …
阅读更多...
预处理详解

预处理详解

目录 一&#xff1a;预定义符号 二&#xff1a;#define定义常量 三&#xff1a;#define定义宏 四&#xff1a;带有副作用的宏定义 五&#xff1a;宏的替换规则 六&#xff1a;宏函数的对比 七&#xff1a;# 和 ## 7.1 #运算 7.2 ##预算符 八&#xff1a;命名约定 九&…
阅读更多...
mac电脑版MATLAB R2023b for Mac中文激活版

mac电脑版MATLAB R2023b for Mac中文激活版

MATLAB R2023b for Mac&#xff1a;科学计算的终极工具 软件下载&#xff1a;MATLAB R2023b for Mac中文激活版下载 &#x1f52c; 探索科学&#xff0c;无限可能 MATLAB R2023b for Mac&#xff0c;助您深入挖掘科学计算的奥秘。从数据分析、算法设计到可视化展示&#xff0c;…
阅读更多...
物联网导论

物联网导论

物联网起源 物联网&#xff1a;是一个基于互联网、传统电信网等信息承载体&#xff0c;让所有能够被独立寻址的普通物理对象实现互联互通的网络。它具有普通对象设备化、自治终端互联化和普适服务智能化三个重要特征。 按照规定的协议&#xff0c;将具有感知、通信、计算等功…
阅读更多...
T2 小美的平衡矩阵(25分) - 美团编程题 题解

T2 小美的平衡矩阵(25分) - 美团编程题 题解

考试平台&#xff1a; 牛客网 题目类型&#xff1a; 30道单选题&#xff08;60分&#xff09; 2 道编程题 &#xff08;15分 25分&#xff09; 考试时间&#xff1a; 2024-03-09 &#xff08;两小时&#xff09; 题目描述 小美拿到了一个n*n的矩阵&#xff0c;其中每个元素是…
阅读更多...
简单BFF架构设计

简单BFF架构设计

又到周五了有了一个小时的闲暇时间简单写点东西&#xff0c;介绍一个简单的BFF的架构。BFF:Backends For Frontends,其实现在是个比较常见的前端架构设计的方案&#xff0c;其最大的优势便在于前端可以高度自由的在Node层做一些server端才可以做的东西&#xff0c;比如SSR、登录…
阅读更多...
【JavaEE进阶】Spring中事务的实现

【JavaEE进阶】Spring中事务的实现

文章目录 &#x1f343;前言&#x1f334;事务简介&#x1f6a9; 什么是事务?&#x1f6a9;为什么需要事务?&#x1f6a9;事务的操作 &#x1f340;Spring 中事务的实现&#x1f6a9;Spring 编程式事务&#x1f6a9;Spring声明式事务Transactional&#x1f6a9;Transactional…
阅读更多...
Using WebView from more than one process

Using WebView from more than one process

关于作者&#xff1a;CSDN内容合伙人、技术专家&#xff0c; 从零开始做日活千万级APP。 专注于分享各领域原创系列文章 &#xff0c;擅长java后端、移动开发、商业变现、人工智能等&#xff0c;希望大家多多支持。 未经允许不得转载 目录 一、导读二、概览三、问题过程源码追踪…
阅读更多...
Pinctrl子系统_04_Pinctrl子系统主要数据结构

Pinctrl子系统_04_Pinctrl子系统主要数据结构

引言 本节说明Pinctrl子系统中主要的数据结构&#xff0c;对这些数据结构有所了解&#xff0c;也就是对Pinctrl子系统有所了解了。 前面说过&#xff0c;要使用Pinctrl子系统&#xff0c;就需要去配置设备树。 以内核面向对象的思想&#xff0c;设备树可以分为两部分&#x…
阅读更多...
ssrf漏洞

ssrf漏洞

SSRF漏洞概述和演示 SSRF&#xff08;Server-Side Request Forgery&#xff0c;服务器端请求伪造&#xff09;是一种常见的Web应用程序安全漏洞。它允许攻击者诱使服务器端应用程序发起任意HTTP(S)请求到内部系统或者网络&#xff0c;而这些请求通常是正常情况下服务器自身为了…
阅读更多...
MYSQL | 数据库到底是怎么来的？

MYSQL | 数据库到底是怎么来的？

“以史为鉴&#xff0c;可以让我们更深刻地理解现在&#xff0c;预见未来。” 要想知道一件东西是怎么发生的, 我们不妨把时间拨回关系型数据库被提出前后来探索。在信息技术飞速发展的今天&#xff0c;回望数据库管理系统的演进之路&#xff0c;我们可以深刻理解到技术进步如…
阅读更多...
产品推荐 - 基于6U VPX的双TMS320C6678+Xilinx FPGA K7 XC7K420T的图像信号处理板

产品推荐 - 基于6U VPX的双TMS320C6678+Xilinx FPGA K7 XC7K420T的图像信号处理板

综合图像处理硬件平台包括图像信号处理板2块&#xff0c;视频处理板1块&#xff0c;主控板1块&#xff0c;电源板1块&#xff0c;VPX背板1块。 一、板卡概述 图像信号处理板包括2片TI 多核DSP处理器-TMS320C6678&#xff0c;1片Xilinx FPGA XC7K420T-1FFG1156&#xff0c;1片…
阅读更多...
20240309-1-校招前端面试常见问题-前端框架及常用工具

20240309-1-校招前端面试常见问题-前端框架及常用工具

校招前端面试常见问题【5】——前端框架及常用工具 React Q&#xff1a;请简述一下虚拟 DOM 的概念&#xff1f; 基于 React 进行开发时所有的 DOM 构造都是通过虚拟 DOM 进行&#xff0c;每当数据变化时&#xff0c;React 都会重新构建整个 DOM 树&#xff0c;然后 React 将…
阅读更多...
selenium之PO设计模式

selenium之PO设计模式

初识PO模式 PO&#xff08;PageObject&#xff09;是一种设计模式。简单来说就是把一些繁琐的定位方法、元素操作方式等封装到类中&#xff0c;通过类与类之间的调用完成特定操作。 PO被认为是自动化测试项目开发实践的最佳设计模式之一。 在学习PO模式前&#xff0c;可以先…
阅读更多...
力扣日记3.8-【回溯算法篇】37. 解数独

力扣日记3.8-【回溯算法篇】37. 解数独

力扣日记&#xff1a;【回溯算法篇】37. 解数独 日期&#xff1a;2023.3.8 参考&#xff1a;代码随想录、力扣 37. 解数独 题目描述 难度&#xff1a;困难 编写一个程序&#xff0c;通过填充空格来解决数独问题。 数独的解法需 遵循如下规则&#xff1a; 数字 1-9 在每一行只…
阅读更多...
存货计价方式 比较-移动平均和批次计价

存货计价方式 比较-移动平均和批次计价

SAP常用的存货计价方式有 标准价格移动平均价格批次计价 标准价格常用于制造企业&#xff0c;今天的方案比较主要集中在销售型企业常用的移动平均价和批次计价 批次计价&#xff1a; 移动平均&#xff1a; 两种计价方式的Pros&Cons 比较 批次计价 移动平均优点 1…
阅读更多...
最新文章

Copyright @ 2022~2023