C++——string模拟实现

前言:上篇文章我们对string类及其常用的接口方法的使用进行了分享,这篇文章将着重进行对这些常用的接口方法的内部细节进行分享和模拟实现。


目录

一.基础框架

二.遍历字符串

1.[]运算符重载

2.迭代器

3.范围for

三.常用方法

1.增加

2.删除

3.调整

4.交换

5.查找

6.截取

7.比较

四.流操作

总结


一.基础框架

首先我们要清楚,string类定义的是字符串对象,所以就类似于线性表,有长度,容量等成员变量:

	class string
	{
	public:
		//构造函数
		string(const char* str = "")
			:_size(strlen(str))
		{
			_capacity = _size;
			_str = new char[_capacity + 1];
			strcpy(_str, str);
		}
		//析构函数
		~string()
		{
			delete[] _str;
			_str = nullptr;
			_size = 0;
			_capacity = 0;
		}
		//转换C语言格式
		const char* c_str() const
		{
			return _str;
		}
		//清除
		void clear()
		{
			_size = 0;
			_str[_size] = '\0';
		}
        //深拷贝s2(s1)
		string(const string& s)
		{
			_str = new char[_capacity + 1];
			strcpy(_str, s._str);
			_size = s._size;
			_capacity = s._capacity;
		}
		//s1 = s2
		string& operator=(const string& s)
		{
			char* tmp = new char[s._capacity + 1];
			strcpy(tmp, s._str);
			delete[] _str;
			_str = tmp;
			_size = s._size;
			_capacity = s._capacity;
		}
	private:

		char* _str;
		size_t _size;
		size_t _capacity;
	};

其中不能缺少的就是构造函数、析构函数和拷贝构造函数,这里我们直接用缺省函数将无参构造和带参构造结合为一体

但是由于如果我们不自己写一个深拷贝函数,就会默认执行浅拷贝成员函数,这样会导致两个字符串同源,所以需要给出深拷贝函数。

值得注意的是真正的strlen不会统计字符串中的‘\0’,所以我们给_str开空间时应+1。


二.遍历字符串

1.[]运算符重载

上篇文章中我们知道遍历字符串有三种方式:[]运算符重载,迭代器,以及范围for。下面我们就来一一实现。

首先我们需要将字符串的长度方法size和容量方法capacity定义出来:

		//长度
		size_t size() const
		{
			return _size;
		}
		//容量
		size_t capacity() const
		{
			return _capacity;
		}

一般情况下当方法里调用的成员无需发生改变时,都会将这些方法用const修饰。 

[]运算符重载自然是通过运算符重载函数来实现:

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

这里我们添加assert函数来断言,防止越界访问

返回值使用引用格式,能够实现可读可写

 但此时会产生一个问题,如果我想让一个const修饰的对象来调用该方法,就会导致权限放大而出错

如果给这个方法加上const,那我们就无法修改其内容了

所以我们使用函数重载为其单独创造一个只读的const修饰的函数方法

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

2.迭代器

我们已经了解迭代器的本质和指针类似,我们这里我们就先用指针的实现迭代器的功能

		//迭代器
		typedef char* iterator;
		iterator begin()
		{
			return _str;
		}
		iterator end()
		{
			return _str + _size;
		}

用typedef将char*指针重命名为iterator再定义出begin和end两个方法,便能实现迭代器功能:

值得注意的是,const修饰的对象想要调用迭代器,也必须调用对应const修饰的迭代器,所以迭代器我们也需要进行重载

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

迭代器这样的模拟实现方法也能帮助我们更深入的了解其内部构造。


3.范围for

范围for实际上并没有那么复杂,其本质也是迭代器

所以只要有迭代器的存在,保证iterator、begin。end这些单词不变,不管是我们自己实现的还是C++库内的,都可以使用范围for:

但是如果iterator、begin。end这些单词发生变化,就无法在使用范围for。 


三.常用方法

1.增加

增加无非有四种方式:尾插单个字符push_back、尾插字符串append和+=运算符重载,以及任意位置的插入insert,增加字符就意味着要考虑扩容问题,这就要实现reserve方法来配合使用。

尾插单个字符可以通过每次扩容两倍容量,但是如果尾插一个长度为len的字符串,每次扩容两倍或是更多倍都并不一定就能满足容量, 所以这里直接扩容size+len个空间

		//扩容
		void reserve(size_t len)
		{
			if (len > _capacity)
			{
				char* tmp = new char[len + 1];
				strcpy(tmp, _str);
				delete[] _str;
				_str = tmp;
				_capacity = len;
			}
		}
		//尾插单字符
		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 (_size + len > _capacity)
			{
				reserve(_size + len);
			}
			strcpy(_str + _size, str);
			_size += len;
		}

因为字符串的末尾都要有'\0'的存在,所以扩容时,要始终保持实际容量比字符串容量多1

当尾插单个字符时,因为该字符是直接覆盖了'\0',所以尾插之后要再字符串末尾再补上'\0'

而尾插字符串时,因为strcpy在进行拷贝时也会直接将'\0'拷贝,所以无需再补。 

+=运算符的重载,就是以上述两个方法为基层的扩展

		//+=运算符重载
		string& operator+=(char ch)
		{
			push_back(ch);
			return *this;
		}
		string& operator+=(const char* str)
		{
			append(str);
			return *this;
		}

测试如下:


任意位置的插入, 则需要进行字符串的挪动

		//任意位置插入
		//单字符
		void insert(char ch, size_t pos)
		{
			assert(pos <= _size);
			if (_size == _capacity)
			{
				reserve(_capacity == 0 ? 4 : _capacity * 2);
			}
			size_t end = _size + 1;
			while (end > pos)
			{
				_str[end] = _str[end - 1];
				end--;
			}
			_str[pos] = ch;
			_size++;

		}
		//字符串
		void insert(const char* str, size_t pos)
		{
			assert(pos <= _size);
			size_t len = strlen(str);
			if (_size + len > _capacity)
			{
				reserve(_size + len);
			}
			size_t end = _size + len;
			while (end >= pos + len)
			{
				_str[end] = _str[end - len];
				end--;
			}
			for (size_t i = 0; i < len; i++)
			{
				_str[pos++] = str[i];
			}
			_size += len;
		}

在进行字符串插入时,要注意的是我们要从pos位置将后边的字符向后空出len个位置

同时我们不能使用strcpy进行插入,因为它会将要插入的字符串的'\0'一并插入,导致一个位置的字符被覆盖,所以这里我们采用循环插入。

 测试如下:


2.删除

string类中只有一个常用的删除方法:erase,它的功能是在指定位置后删除若干个字符,如果没有指定要删除的字符数量,则默认将后边的字符全删除

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

采用缺省函数的方式,如果我们没有传入len,他就会等于npos,npos在C++中表示一个常数,表示不存在的位置

如果len无传入或是len的长度不小于要删除的字符串长度,这都可以认为是要将pos位置后的字符串全部删除,此时便可直接在pos位置用'\0'

使用npos需要在类中定义public成员变量:

    public:
        static const int npos;

以及在类外赋值:

    const int string::npos = -1;

 测试如下:


3.调整

在string中有一个方法可以兼备增加和删除两种简单功能,名为resize,它的作用是调整字符串

传入一个参数n,和一个字符ch如果当前字符串长度小于n,则扩容字符串长度至n个,并将多出的位置用字符ch填充,如果不传字符ch,则默认填充'\0'

如果当前字符串长度大于n,则将字符串长度缩减到n

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

测试如下:


4.交换

自己实现string类中的swap交换函数,有一个很好用的方法,那就是借用std库中的swap函数

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

 因为std库中的swap函数是模版函数,可以进行任意类型的交换,所以我们直接投机取巧,将两者的成员变量依次进行交换,测试如下:

 但是这样的写法并不是我们所熟悉的swap(s1,s2),所以我们可以通过函数重载扩展一下

		void swap(string& x, string& y)
		{
			x.swap(y);
		}

值得注意的是这个函数要写在string类的外边,按照就近原则去调用它,否则会默认先调用库里的模版swap函数。 

测试如下:


5.查找

string类中的查找也分为查找单个字符、查找字符串以及在指定的pos位置向后去查找找到返回下标,找不到返回npos,所以依然要使用缺省函数

		//查找
		//单字符
		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 char* str, size_t pos = 0) const
		{
			assert(pos < _size);
			const char* p = strstr(_str + pos, str);
			if (p)
				return p - _str;
			else
				return npos;
		}

在查找字符串时我们使用到了strstr函数其返回值为所找到的字符串的首字符指针

测试如下:


6.截取

截取字符串方法substr,其作用是从字符串的pos位置开始向后截取len长度的字符,当然无论是pos位置还是长度len都可以没有,依然是缺省函数

		//截取
		string substr(size_t pos = 0, size_t len = npos)
		{
			string sub;
			if (len >= _size - pos)
			{
				for (size_t i = pos; i < _size; i++)
				{
					sub += _str[i];
				}
			}
			else
			{
				for (size_t i = pos; i < pos + len; i++)
				{
					sub += _str[i];
				}
			}
			return sub;
		}

测试如下:


7.比较

字符串直接的比较需要我们实现运算符重载

	bool operator==(const string& s1, const string& s2)
	{
		int ret = strcmp(s1.c_str(), s2.c_str());
		return ret == 0;
	}
	bool operator<(const string& s1, const string& s2)
	{
		int ret = strcmp(s1.c_str(), s2.c_str());
		return ret < 0;
	}
	bool operator<=(const string& s1, const string& s2)
	{
		return s1 < s2 || s1 == s2;
	}
	bool operator>(const string& s1, const string& s2)
	{
		return !(s1 <= s2);
	}
	bool operator>=(const string& s1, const string& s2)
	{
		return !(s1 < s2);
	}
	bool operator!=(const string& s1, const string& s2)
	{
		return !(s1 == s2);
	}

这一块的方法,我们建议实现在类外,定义两个参数,这样能够允许一个字符串和一个string对象进行比较

因为在类内定义因为默认类内的成员函数的第一个参数都是隐藏的非静态string对象,所以静态的普通字符串传入就会使权限放大而出错

测试如下:

 


四.流操作

直接上代码:

	//流输出
	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;
		ch = in.get();
		while (ch != ' ' && ch != '\n')
		{
			s += ch;
			ch = in.get();
		}
		return in;
	}

输出较为简单,直接使用范围for循环输出

而对于提取到的字符会直接覆盖s中原有的字符串,所以要先进行清除;此外,因为in默认会跳过空格和回车而不提取它们,这会导致死循环,所以我们使用in.get()函数来提取

测试如下:


总结

关于string类及其内部常用方法的模拟实现就分享到这里啦。

最后希望能得到您的一键三连支持,我们下期再见!

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

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

相关文章

spring boot 2.4.x 之前版本(对应spring-cloud-openfeign 3.0.0之前版本)feign请求异常逻辑

目录 feign SynchronousMethodHandler 第一部分 第二部分 第三部分 spring-cloud-openfeign LoadBalancerFeignClient ribbon AbstractLoadBalancerAwareClient 在之前写的文章配置基础上 https://blog.csdn.net/zlpzlpzyd/article/details/136060312 因为从 spring …

Excel F4键的作用

目录 一. 单元格相对/绝对引用转换二. 重复上一步操作 一. 单元格相对/绝对引用转换 ⏹ 使用F4键 如下图所示&#xff0c;B1单元格引用了A1单元格的内容。此时是使用相对引用&#xff0c;可以按下键盘上的F4键进行相对引用和绝对引用的转换。 二. 重复上一步操作 ⏹添加或删除…

【Python】装饰器函数

专栏文章索引&#xff1a;Python 原文章&#xff1a;装饰器函数基础_装饰函数-CSDN博客 目录 1. 学习装饰器的基础 2.最简单的装饰器 3.闭包函数装饰器 4.装饰器将传入的函数中的值大写 5. 装饰器的好处 6. 多个装饰器的执行顺序 7. 装饰器传递参数 8. 结语 1. 学习装饰…

c++中string的模拟实现(超详细!!!)

1.string的成员变量、&#xff08;拷贝&#xff09;构造、析构函数 1.1.成员变量 private:char* _str;size_t _size; //string中有效字符个数size_t _capacity; //string中能存储有效字符个数的大小 1.2&#xff08;拷贝&#xff09;构造函数 //构造函数string(const char* …

Chain of Verification(验证链、CoVe)—理解与实现

原文地址&#xff1a;Chain of Verification (CoVe) — Understanding & Implementation 2023 年 10 月 9 日 GitHub 存储库 介绍 在处理大型语言模型&#xff08;LLM&#xff09;时&#xff0c;一个重大挑战&#xff0c;特别是在事实问答中&#xff0c;是幻觉问题。当答案…

React-路由导航

1.声明式路由导航 1.1概念 说明&#xff1a;声明式导航是指通过在模版中通过<Link/>组件描述出要跳转到哪里去&#xff0c;比如后台管理系统的左侧菜单通常使用这种方式进行。 import {Link} from "react-router-dom" const Login()>{return (<div>…

资源哟正版无授权模版源码(含搭建教程)

资源哟 v1.3 – 新增两种首页布局 – 新增幻灯片插件 – 优化深色模式颜色效果 – 优化导航页面左侧栏目跳转效果 – 优化后台辅助插件当前页面打开 源码下载&#xff1a;https://download.csdn.net/download/m0_66047725/88898100 更多资源下载&#xff1a;关注我。

Linux多线程之线程控制

(&#xff61;&#xff65;∀&#xff65;)&#xff89;&#xff9e;嗨&#xff01;你好这里是ky233的主页&#xff1a;这里是ky233的主页&#xff0c;欢迎光临~https://blog.csdn.net/ky233?typeblog 点个关注不迷路⌯▾⌯ 目录 一、pthread_crate 二、pthread_join 三、p…

RAG、数据隐私、攻击方法和安全提示

原文地址&#xff1a;RAG, Data Privacy, Attack Methods & Safe-Prompts 最近的一项研究探讨了 RAG 安全漏洞以及通过检索数据集访问私有数据的方式。还讨论了防御和安全提示工程示例。 介绍 RAG 在构建生成式 AI 应用程序中非常受欢迎。RAG 在生成式 AI 应用中采用的原因…

Elasticsearch架构原理

一. Elasticsearch架构原理 1、Elasticsearch的节点类型 在Elasticsearch主要分成两类节点&#xff0c;一类是Master&#xff0c;一类是DataNode。 1.1 Master节点 在Elasticsearch启动时&#xff0c;会选举出来一个Master节点。当某个节点启动后&#xff0c;然后使用Zen D…

指针数组和数组指针(详细解释)

指针数组 指针数组的作用 指针数组和数组指针是C语言中常用的概念&#xff0c;它们分别有不同的作用和用法。 指针数组&#xff1a; 指针数组是一个数组&#xff0c;其中的每个元素都是指针类型。它可以用来存储多个指针&#xff0c;每个指针可以指向不同的数据类型或者相同…

Pytorch学习 day08(最大池化层、非线性激活层、正则化层、循环层、Transformer层、线性层、Dropout层)

最大池化层 最大池化&#xff0c;也叫上采样&#xff0c;是池化核在输入图像上不断移动&#xff0c;并取对应区域中的最大值&#xff0c;目的是&#xff1a;在保留输入特征的同时&#xff0c;减小输入数据量&#xff0c;加快训练。参数设置如下&#xff1a; kernel_size&#…

类与对象-对象特性

师从黑马程序员 对象的初始化和清理 构造函数和析构函数 用于完成对象的初始化和清理工作 如果我们不提供构造和析构&#xff0c;编译器会提供编译器提供的构造函数和析构函数是空实现 构造函数&#xff1a;主要用于创建对象时为对象的成员属性赋值&#xff0c;构造函数由编…

了解华为(PVID VLAN)与思科的(Native VLAN)本征VLAN的区别并学习思科网络中二层交换机的三层结构局域网VLAN配置

一、什么是二层交换机&#xff1f; 二层交换机&#xff08;Layer 2 Switch&#xff09;是一种网络设备&#xff0c;主要工作在OSI模型的数据链路层&#xff08;第二层&#xff09;&#xff0c;用于在局域网内部进行数据包的交换和转发。二层交换机通过学习MAC地址表&#xff0…

毅速3D打印随形透气钢:模具困气排气革新之选

在注塑生产过程中&#xff0c;模具内的气体若无法有效排出&#xff0c;往往会引发困气现象&#xff0c;导致产品表面出现气泡、烧焦等瑕疵。这些瑕疵不仅影响产品的美观度&#xff0c;更可能对其性能造成严重影响&#xff0c;甚至导致产品报废&#xff0c;从而增加生产成本。 传…

政安晨:【深度学习处理实践】(四)—— 实施一个温度预测示例

在开始使用像黑盒子一样的深度学习模型解决温度预测问题之前&#xff0c;我们先尝试一种基于常识的简单方法。 它可以作为一种合理性检查&#xff0c;还可以建立一个基准&#xff0c;更高级的机器学习模型需要超越这个基准才能证明其有效性。对于一个尚没有已知解决方案的新问…

Linux之生产消费者模型

(&#xff61;&#xff65;∀&#xff65;)&#xff89;&#xff9e;嗨&#xff01;你好这里是ky233的主页&#xff1a;这里是ky233的主页&#xff0c;欢迎光临~https://blog.csdn.net/ky233?typeblog 点个关注不迷路⌯▾⌯ 我们在条件满足的时候&#xff0c;唤醒指定的线程&a…

超越Chain-of-Thought LLM 推理

原文地址&#xff1a;Beyond Chain-of-Thought LLM Reasoning 2024 年 2 月 13 日 介绍 最近的一项研究解决了需要增强大型语言模型 (LLM) 的推理能力&#xff0c;超越直接推理 (Direct Reasoning&#xff0c;DR) 框架&#xff0c;例如思想链和自我一致性&#xff0c;这些框架可…

分割模型TransNetR的pytorch代码学习笔记

这个模型在U-net的基础上融合了Transformer模块和残差网络的原理。 论文地址&#xff1a;https://arxiv.org/pdf/2303.07428.pdf 具体的网络结构如下&#xff1a; 网络的原理还是比较简单的&#xff0c; 编码分支用的是预训练的resnet模块&#xff0c;解码分支则重新设计了。…

HTML入门:属性

你好&#xff0c;我是云桃桃。今天来聊一聊 HTML 属性写法和特点。 HTML 属性是用于向 HTML 标签&#xff08;也叫 HTML 元素&#xff09;提供附加信息或配置的特性。 如果说&#xff0c;把HTML 标签比作一个房子&#xff0c;HTML 标签定义了房子的结构和用途&#xff0c;比如…