【C++】string类的模拟实现（增删查改，比大小，运算符重载）

news2024/11/24 22:49:48

文章目录

  • 1.1大框架
  • 1.2基本函数：
  • 2.成员函数
    • 2.0构造函数
    • 2.05析构函数
    • 2.09拷贝构造函数
      • 补充：预留存储空间（reserve）
    • 2.1增加字符（push_back，append，s+=）
      • push_back
      • append
      • s+=
    • 2. 删除字符（erase）
    • 2. 查找字符（find）
    • 2. 插入字符（insert）
    • 2. 截取字符（substr）
    • 2. 调整字符串的长度（resize）
    • 2. 比大小（运算符重载）
      • <
      • 复用
    • 2.流插入提取（cout，cin）
      • cout
      • cin
    • 2.赋值运算符重载
    • 2.迭代器

1.1大框架

namespace simulation {
	class string {
	public:
 //成员函数：

	private:
		size_t _size;
		//当前长度
		size_t _capacity;
		//最大容量，不包括'\0'
		char* _str;
		const static size_t npos;
		//表示一个特殊的无效位置（无效的字符串索引或子字符串位置）
		//定义为一个静态常量，具体的值是一个特别大的整数，通常被定义为-1。
	};
	const size_t string::npos=-1;	 
}

1.2基本函数：

const char* c_str()const {
			return _str;
			//打印字符
		}

		size_t size() {
			return _size;
			//字符串长度
		}

		char& operator[](size_t pos) {//可读写
			assert(pos < _size);
			return _str[pos];
		}
		const char& operator[](size_t pos) const{//只可读
			assert(pos < _size);
			return _str[pos];
		}

2.成员函数

2.0构造函数

//构造函数：
		//方法一：无参和有参分开讨论
		string()
			//运用初始化列表
			:_size(0)
			, _capacity(0)
			, _str(new char[1])
		{
			_str[0] = '\0';
		}

		string(const char* str)
			:_size(strlen(str))
			, _capacity(_size)
			, _str(new char[_capacity + 1])
		{
			memcpy(_str, str, _size + 1);
		}
//方法二：直接用缺省参数合并两种情况
		string(const char* str = "") {
			_size = strlen(str);
			_capacity = _size;
			_str = new char[_capacity + 1];
			//开空间要比_capacity多一个，因为
			//capacity的大小不包括'\0'，所以我们要自己加
			memcpy(_str, str, _size + 1);
			//拷贝的字节数为_size + 1是因为我们要算上'\0'
		}

2.05析构函数

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

2.09拷贝构造函数

string(const string& s) {
			_str = new char[s._capacity + 1];
			memcpy(_str, s._str, s._size + 1);
			_size = s._size;
			_capacity = s._capacity;
			 
		}

补充：预留存储空间（reserve）

void reserve(size_t n) {
			if (n > _capacity) {
				char* tmp = new char[n + 1];
				//要包括'\0'的大小所以要+1
				memcpy(tmp, _str, _size + 1);
				//将原字符拷贝到新空间
				delete[] _str;
				_str = tmp;
				_capacity = n;
				//改变最大容量
			}
		}

2.1增加字符（push_back，append，s+=）

push_back

void push_back(char ch) {
			if (_size == _capacity) {
				reserve(_capacity == 0 ? 4 : 2 * _capacity);
				//检查容量是否够
			}
			_str[_size] = ch;
			++_size;
			_str[_size] = '\0';
		}

append

void append(const char* str) {
			size_t  len = strlen(str);
			if (len + _size > _capacity) {
				//检查容量是否够
				reserve(len + _size);//扩容
			}
			memcpy(_str + _size, str, len + 1);
			//从末尾开始拷贝，len个字符再加上'\0'
			_size += len;
		}

s+=

string& operator+=(const char* str) {
			//加字符串
			append(str);
			return *this;
		}

		string& operator+=(char ch) {
			//只加一个字符
			push_back(ch);
			return *this;
		}

2. 删除字符（erase）

在这里插入图片描述

void erase(size_t pos, size_t len = npos) {
			assert(pos <= _size);
			if (len == npos || len + pos >= _size) {
				//要删除长度等于当前最大长度
				//或从删除位置开始加上要删除的长度
				//大于等于当前最大长度

				//相当于直接把pos朝后面的都删完
				_size = pos;
				_str[_size] = '\0';
				
			}
			else {
				size_t end = pos + len;
				//从要删除的数据后一个开始即end
				//移动到pos位置
				while (end<=_size) {
					_str[pos++] = _str[end++];
				}
				_size -= len;
			}
		}

2. 查找字符（find）

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

		size_t find(const char* str, size_t pos = 0) {
			//查找字符串
			assert(pos < _size);
			const char* ptr = strstr(_str, str);
			if (ptr) {
				return ptr - _str;
				//两个指针相减即两指针相距的元素个数
				//_str下标为0
			}
				return npos;
		}

2. 插入字符（insert）

在这里插入图片描述

void insert(size_t pos, size_t n, char ch) {
			assert(pos <= _size);
			if (n + _size > _capacity) {
				reserve(n + _size);
			}
			size_t end = _size;
			//方法一*while (end >= (int)pos) {会发生整形提升
			// 所以要把pos强转要不会死循环
				//_str[end + n] = _str[end];
				//end--;
			//}*/

			while (end >= pos && end != npos) {//方法二
				_str[end + n] = _str[end];
				end--;
			}
			for (size_t i = 0; i < n; i++) {
				_str[pos + i] = ch;
			}
			_size += n;
		}

		void insert(size_t pos, const char* str) {
			assert(pos <= _size);
			size_t  len = strlen(str);
			if (len + _size > _capacity) {
				// 至少扩容到_size + len
				reserve(len + _size);
			}
			size_t end = _size;
			//从最后一个位置，将end与pos之间
			//的字符都朝后面移动len个单位
			while (end >= pos&&end!=npos) {
				_str[len + end] = _str[end];
				end--;
			}
			for (size_t i = 0; i < len; i++) {
				_str[pos + i] = str[i];
			}
			//将要插入字符串放入
			_size += len;

		}

2. 截取字符（substr）

string  substr(size_t pos=0, size_t len = npos) {
			assert(pos < _size);
			size_t n = len;
			//判断要截取长度大小
			//看是否要pos之后截取全部
			if (len == npos || len + pos > _size) {
				n = _size - pos;
			}
			string tmp;
			tmp.reserve(n);//扩容
			for (size_t i = pos; i < pos + n; i++)
			{
				tmp += _str[i];
			}
			return tmp;
		}

2. 调整字符串的长度（resize）

void resize(size_t n,char ch='\0') {
			if (n < _size) {
				//如果n小于当前长度，则字符串被截断
				_str[n] = '\0';
				_size = n;
			}
			else {
				//如果n大于当前长度，则字符串被填充到指定长度并用ch进行填充。
				reserve(n);
				for (size_t i = _size; i < n; i++) {
					_str[i] = ch;
				}
				_size = n;
				_str[_size] = '\0';
			}
		}

2. 比大小（运算符重载）

<

//方法一
		bool operator<(const string& s)const {
			int i1 = 0;
			int i2 = 0;
			while (i1 < _size && i2 < s._size) {
				if (_str[i1] < s._str[i2]) {
					return true;
				}
				else if (_str[i1] > s._str[i2]) {
					return false;
				}
				else {
					i1++;
					i2++;
				}
			}
			// "hello" "hello"   false
			// "helloxx" "hello" false
			// "hello" "helloxx" true
			return _size < s._size;
		}
		//方法二：精简版
		bool operator<(const string& s)const {
			int ret = memcmp(_str, s._str, _size < s._size ? _size : s._size);
			return ret == 0 ? _size < s._size : ret < 0;
		}

复用

bool operator==(const string& s)const {
			return _size == s._size && 
			memcmp(_str, s._str, _size) == 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);
		}

2.流插入提取（cout，cin）

cout

ostream& operator<<(ostream& out, const simulation::string& s)
{
	for (auto ch : s)
	{
		out << ch;
	}

	return out;
}

cin

void clear() {
			_str[0] = '\0';
			_size = 0;
		}
``istream& operator>>(istream& in,  simulation:: string& s) {
	s.clear();
	//清除缓冲区
	char ch = in.get();
	// 处理前缓冲区前面的空格或者换行
	while (ch == ' ' || ch== '\n') {
		ch = in.get();
	}
	char buff[128];
	//有了初始空间可避免反复扩容
	int 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;
}

2.赋值运算符重载

v

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

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

2.迭代器

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

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

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

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

相关文章

SpringCloud-Alibaba之Seata处理分布式事务

SpringCloud-Alibaba之Seata处理分布式事务

一ID三组件模型 Transaction ID XID 全局唯一的事务ID Transaction Coordinator(TC) 事务协调器&#xff0c;维护全局事务的运行状态&#xff0c;负责协调并驱动全局事务的提交或回滚 Transaction Manager™ 控制全局事务的边界&#xff0c;负责开启一个全局事务&#xff0c;…
阅读更多...
Java当中的深拷贝和浅拷贝

Java当中的深拷贝和浅拷贝

文章目录 一、前提二、浅拷贝1. BeanUtils实现浅拷贝 三、深拷贝1. 实现Cloneable接口并重写clone()方法&#xff1a;2. 使用序列化与反序列化&#xff1a; 一、前提 在计算机的内存中&#xff0c;每个对象都被赋予一个地址&#xff0c;该地址指向对象在内存中存储的位置。当我…
阅读更多...
超详细图文教程：3DS Max 中创建低多边形游戏长剑模型

超详细图文教程：3DS Max 中创建低多边形游戏长剑模型

推荐&#xff1a; NSDT场景编辑器助你快速搭建可二次开发的3D应用场景 在此&#xff0c;由两部分组成的教程的第一部分中&#xff0c;我将向您展示如何&#xff1a; 对剑柄进行建模剑的护手模型剑刃建模 1. 如何制作剑柄 步骤 1 在本教程中使用正交视图。要更改视图&#x…
阅读更多...
uniapp小程序跳转其他小程序uni.navigateToMiniProgram效果demo（整理）

uniapp小程序跳转其他小程序uni.navigateToMiniProgram效果demo（整理）

放点击事件里面即可 uni.navigateToMiniProgram({appId: , //跳转的小程序的aooIdpath: pages/index/index?id123, //如果这里不填&#xff0c;默认是跳转到对方小程序的主页面extraData: { //需要传给对方小程序的数据data1: test},success(res) {// 打开成功} })
阅读更多...
Leetcode每日一题：42. 接雨水（2023.7.23 C++）

Leetcode每日一题：42. 接雨水（2023.7.23 C++）

目录 42. 接雨水 题目描述&#xff1a; 实现代码与解析&#xff1a; 单调栈 原理思路&#xff1a; 动态规划 原理思路&#xff1a; 42. 接雨水 原题链接&#xff1a; 42. 接雨水 题目描述&#xff1a; 给定 n 个非负整数表示每个宽度为 1 的柱子的高度图&#xff0c;…
阅读更多...
SVTR: 使用单一视觉模型进行场景文本识别【论文翻译】

SVTR: 使用单一视觉模型进行场景文本识别【论文翻译】

&#x1f947; 版权: 本文由【墨理学AI】原创首发、各位读者大大、敬请查阅、感谢三连 &#x1f389; 声明: 作为全网 AI 领域 干货最多的博主之一&#xff0c;❤️ 不负光阴不负卿 ❤️ 文章目录 SVTR: Scene Text Recognition with a Single Visual ModelAbstract1 Introduct…
阅读更多...
Ansible部署与实施PlayBook

Ansible部署与实施PlayBook

Ansible部署与实施PlayBook 计算机名称IP角色workstation192.168.182.130管理servera192.168.182.131被管理serverb192.168.182.132被管理serverc192.168.182.133被管理 部署 控制节点 官方文档 Ansible易于安装。只需要安装到要运行它的一个或多个控制节点上。由Ansbile管…
阅读更多...
【事业单位-语言理解】中心理解01

【事业单位-语言理解】中心理解01

【事业单位-语言理解】中心理解01 一、中心理解1.1 转折关系1.2 因果关系1.3必要条件关系 二、总结 一、中心理解 1.1 转折关系 转折之后是中心意思 转折在分述句子中&#xff0c;就没有那么重要 1.2 因果关系 一方面另一方面起到的是分述的作用&#xff0c;一般不要过多…
阅读更多...
python解析markdown

python解析markdown

python解析markdown 1、安装markdown模块2、python解析markdown2.1 QtWebEngineWidgets显示网页2.1.1 网页加载2.1.2 网页加载错误 2.2 Python-Markdown 模块库2.3 QTextDocument、QTextBrowser、QTextEdit 3、案例Demo3.1 先上图3.2 代码文件 1、安装markdown模块 pip instal…
阅读更多...
ElasticSearch学习--操作

ElasticSearch学习--操作

目录 索引库操作 mapping映射 总结 创建索引库 查询删除修改索引库 总结 文档操作 添加 查询&#xff0c;删除 修改文档 总结 RestClient操作索引库 初始化JavaRestClient 创建索引库​编辑 删除索引库&#xff0c;判断索引库是否存在 总结 操作文档 新增文档 查询文…
阅读更多...
JAVA SE -- 第九天

JAVA SE -- 第九天

&#xff08;全部来自“韩顺平教育”&#xff09; 一、类变量个类方法 &#xff08;一&#xff09;类变量 1、基本介绍 类变量也叫静态变量/静态属性&#xff0c;是该类的所有对象共享的变量&#xff0c;任何一个该类的对象去访问它时&#xff0c;取到的都是相同的值&#…
阅读更多...
2023年的深度学习入门指南(18) - 将LLaMA2跑起来

2023年的深度学习入门指南(18) - 将LLaMA2跑起来

2023年的深度学习入门指南(18) - 将LLaMA2跑起来 之前我们说到过&#xff0c;在GPT 3之后&#xff0c;大模型就很少有开源的了。其中&#xff0c;最为典型的开源支持者就是Meta公司的研究团队。年初他们发布的LLaMA基本上是各家开源模型的主要参考对象。不过&#xff0c;LLaMA…
阅读更多...
Python 算法基础篇之集合和字典：创建、访问、添加和删除元素

Python 算法基础篇之集合和字典：创建、访问、添加和删除元素

Python 算法基础篇之集合和字典&#xff1a;创建、访问、添加和删除元素 引言 1. 集合的概念和创建2. 集合的访问3. 集合的添加和删除元素 a ) 添加元素 b ) 删除元素 4. 字典的概念和创建5. 字典的访问6. 字典的添加和删除元素 a ) 添加元素 b ) 删除元素 总结 引言 集合和字…
阅读更多...
SAP从放弃到入门系列之批次派生-Batch Derivation-Part2

SAP从放弃到入门系列之批次派生-Batch Derivation-Part2

文章目录 一、派生的类型1.1 静态派生1.2 动态派生 二、派生的方向 通过批次派生的基本配置和简单功能的介绍&#xff0c;大家应该对批次派生有一个基本的了解&#xff0c;这篇文章从批次派生的类型和批次派生的方向两个维度更深入的聊一下它的功能。 一、派生的类型 派生的类…
阅读更多...
OPTEE之sonarlint静态代码分析实战一——optee_os

OPTEE之sonarlint静态代码分析实战一——optee_os

ATF(TF-A)/OPTEE之静态代码分析汇总 一、OPTEE源码下载及分析 对OPTEE实施soanrlint静态代码扫描之前，先到官方网站下载源码。官方网站位于github，网址OP-TEE GitHub。 其中我们重点关注optee_os和optee_client。此页面下的optee_linuxdriver已废弃，该部分最终会编…
阅读更多...
数据结构：二叉树遍历

数据结构：二叉树遍历

概述 二叉树的遍历是指按照某条搜索路径访问二叉树中的每个结点&#xff0c;使得每个结点均被访问一次&#xff0c;而且仅被访问一次。二叉树的遍历方式主要有&#xff1a;先序遍历、中序遍历、后序遍历、层次遍历。先序、中序、后序其实值得是父节点被访问的次序。若在遍历过…
阅读更多...
一.MySQL的主从复制

一.MySQL的主从复制

目录 一.MySQL的主从复制 1.2主从复制的工作过程和原理 1.2.1主从复制工作过程为两日志和三线程 ​编辑 1.2.2主从复制的工作原理 1.3主从复制延迟的原因 1.4主从复制的架构 1.5.MySQL四种同步方式 1.5.1异步复制(Async Replication) 1.5.2 同步复制&#xff08;Sync Re…
阅读更多...
Linux内核子系统--进程管理剖析

Linux内核子系统--进程管理剖析

Linux 是一个计算需求不断变化的非常动态的系统。 Linux 计算需求的表示以进程的公共抽象为中心&#xff0c;进程可以是短期的&#xff08;从命令行执行的命令&#xff09;或长期的&#xff08;网络服务&#xff09;。因此&#xff0c;进程的总体管理及其调度非常重要。 在用户…
阅读更多...
EMC学习笔记（十八）滤波器设计

EMC学习笔记（十八）滤波器设计

滤波器设计 1.标准要求2.设计理论2.1 滤波器电路设计过程2.2 插入损耗定义2.3 原始噪声测量2.4 插入损耗计算2.5 滤波失配原则2.6 滤波拓扑选择2.7 滤波参数计算2.8 滤波参数确定 Tips&#xff1a;学习资料来自网络&#xff0c;仅供学习使用。 EMI滤波器设计&#xff08;汽车电…
阅读更多...
JVM系列（9）——调优初体验

JVM系列（9）——调优初体验

学习这篇文章之前&#xff0c;要了解&#xff1a; JVM系列&#xff08;2&#xff09;——垃圾回收 JVM系列&#xff08;3&#xff09;——内存分配与回收策略 先了解概念&#xff1a; 吞吐量&#xff1a;用户执行时间/(用户执行时间垃圾回收时间)&#xff1b;就是干正经事的时间…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023