c++|string模拟实现

news2024/11/15 22:24:47

 

目录

一、string.h

二、string.cpp

三、Test.cpp

对string的各种接口进行一个简易版的模拟实现，在模拟实现完之后对string的底层实现有了进一步的理解，了解大佬的编程写法思路。也算是对string有了一个小总结。

一、string.h

接口的声明。放在.h文件中 

#include <iostream>
#include <string>
#include <assert.h>
using namespace std;


namespace bit
{

	class string
	{
	public:
		typedef char* iterator;//迭代器本质上就是指针
		typedef const char* const_iterator;


		iterator begin() const
		{
			return _str;
		}


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

		string(const char* s = "");


		string(const string& s);


		string& operator=(string s);

		~string();


		void push_back(char c);


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

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

		void append(const char* str);


		void clear();


		void swap(string& s);

		const char* c_str()const;

		//capacity
		size_t size();

		size_t capacity();

		void resize(size_t n, char c = '\0');

		void reserve(size_t n);

		bool empty()const;



		bool operator<(const string& s);

		bool operator<=(const string& s);

		bool operator>(const string& s);

		bool operator>=(const string& s);

		bool operator==(const string& s);
		;
		bool operator!=(const string& s);

		char& operator[](size_t i);

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


		//返回字符第一次在字符串出现的位置
		size_t find(char c, size_t pos = 0) const;
		;
		//在pos位置插入字符c
		string& insert(size_t pos, char c);

		//在pos位置插入字符串
		string& insert(size_t pos, const char* str);


		//返回子串在字符串中出现的位置
		size_t find(const char* str, size_t pos = 0);

		string substr(size_t pos = 0, size_t len = npos);

		//	删除pos位置上的元素，并返回该元素的下一个位置

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


	private:

		size_t _size;
		size_t _capacity;
		char* _str;

		//静态变量可以赋值处理的前提是有const修饰，这个可以看作是编译器的特殊处理，只能适用于整形家族
		static const size_t npos = -1;

	};
	ostream& operator<<(ostream& out, const string& s);
	istream& operator>>(istream& in, string& s);
}

二、string.cpp

接口的各种实现。进行声明定义分离时，要注意格式上的变化，指定类域，声明和定义中，只有声明中可以给缺省值，定义中不能给。string的构造函数有传统写法和现代写法，现代写法更简洁，但和传统写法本质上没有太大的区别

#include "string.h"


namespace bit
{
		//string()
		//	:_str(nullptr)//不能给空，析构时会对空指针解引用，从而报错
		//	,_size(0)
		//	,_capacity(0)
		//{}

		//string()
		//	:_size(0)
		//	,_capacity(_size)
		//	,_str(new char[_capacity + 1])//这样必须给定成员变量声明顺序。
		//{}

		
		string::string(const char* s)
		{

			_size = strlen(s);
			_capacity = _size;
			_str = new char[_capacity + 1];
			strcpy(_str, s);
		}
		//传统写法
	/*	string(const string& s)
		{
			_str = new char[s._capacity + 1];
			_size = s._size;
			_capacity = s._capacity;

			strcpy(_str, s._str);
		}*/

		//现代写法
		string::string(const string& s)
		{
			string tmp(s._str);
			swap(tmp);
		}
		//传统写法
		//string& operator=(const string& s)
		//{
		//	if (*this != s)
		//	{
		//		char* tmp = new char[s._capacity + 1];
		//		delete[] _str;
		//		strcpy(tmp, s._str);
		//		_str = tmp;
		//		_size = s._size;
		//		_capacity = s._capacity;
		//		return *this;
		//	}
		//	return *this;
		//	
		//}

		//现代写法
		/*string& operator=(const string s)
		{
			string tmp(s._str);

			swap(tmp);
			return *this;
		}*/

		string& string::operator=(string s)
		{
			swap(s);
			return *this;
		}
		string::~string()
		{
			delete[] _str;
			_str = nullptr;
			_size = 0;
			_capacity = 0;
		}
		//modify

		void string::push_back(char c)
		{
			if (_size == _capacity)//初始化容量以及判断容量是否满了
			{
				size_t newcapacity = _capacity == 0 ? 4 : _capacity * 2;
				/*		if (_str != "")
						{
							char* tmp = new char[newcapacity + 1];
							memcpy(tmp, _str, _size);
							delete[] _str;
							_str = tmp;
							_capacity = newcapacity;
						}*/
				reserve(newcapacity);
			}
			_str[_size] = c;
			_size++;
			_str[_size] = '\0';

		}
	    string& string::operator+=(char c)
		{
			push_back(c);
			return *this;
		}


		string& string::operator+=(const string& s)
		{
			if (_size + s._size > _capacity)
			{
				reserve(_size + s._size);
			}
			strcpy(_str + _size, s._str);
			_size += s._size;
			return *this;
		}
		string& string::operator+=(const char* str)
		{
			append(str);
			return *this;
		}
		void string::append(const char* str)
		{
			if (_size + strlen(str) > _capacity)
			{
				reserve(_size + strlen(str));
			}
			strcpy(_str + _size, str);
			_size += strlen(str);
		}

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

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

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

		//capacity
		size_t string::size()
		{
			return _size;
		}
		size_t string::capacity()
		{
			return _capacity;
		}
		void string::resize(size_t n, char c)
		{
			if (n > _capacity)
			{
				reserve(n);
				for (int i = _capacity; i < n; i++)
					push_back(c);
			}
			else if (n > _size && n < _capacity)
			{
				for (int i = _size; i < n; i++)
					push_back(c);
			}
			else if (n < _size)
			{
				_str[n] = '\0';
			}
		}
		void string::reserve(size_t n)
		{
			if (n > _capacity)
			{

				char* tmp = new char[n + 1];
				strcpy(tmp, _str);
				delete[] _str;
				_str = tmp;
				//_size = strlen(tmp);
				_capacity = n;
			}
		}
		bool string::empty()const
		{
			return _str == "";
		}



		bool string::operator<(const string& s)
		{
			return strcmp(_str, s._str) < 0;
		}
		bool string::operator<=(const string& s)
		{
			return !(*this > s);
		}
		bool string::operator>(const string& s)
		{
			return strcmp(_str, s._str) > 0;
		}
		bool string::operator>=(const string& s)
		{
			return !(*this < s);
		}
		bool string::operator==(const string& s)
		{
			return strcmp(_str, s._str) == 0;
		}
		bool string::operator!=(const string& s)
		{
			return !(strcmp(_str, s._str) == 0);
		}
		char& string::operator[](size_t i)
		{
			return _str[i];
		}
		const char& string::operator[](size_t i) const
		{
			return _str[i];
		}

		//返回字符第一次在字符串出现的位置
		size_t string::find(char c, size_t pos) const
		{
			assert(pos <= _size);
			for (int i = pos; i < _size; i++)
			{
				if (_str[i] == c)
					return i;
			}
			return npos;
		}
		//在pos位置插入字符c
		string& string::insert(size_t pos, char c)
		{
			assert(pos <= _size);
			if (_size == _capacity)
			{
				size_t newcapacity = _capacity == 0 ? 4 : _capacity * 2;
				reserve(newcapacity);
			}

			if (pos == _size)
				push_back(c);
			else
			{
				size_t len = _size - pos;
				while (len)
				{
					_str[pos + len] = _str[pos + len - 1];
					len--;
				}
				_str[pos] = c;
			}
			_size++;
			_str[_size] = '\0';
			return *this;

		}
		//在pos位置插入字符串
		string& string::insert(size_t pos, const char* str)
		{
			assert(pos <= _size);
			size_t len = strlen(str);

			if (len + _size >= _capacity)
			{
				reserve(len + _size);
			}
			if (pos == _size)
			{
				append(str);
			}
			else
			{
				size_t ilen = _size - pos;
				while (ilen)
				{
					_str[pos + ilen + len] = _str[pos + ilen];

					ilen--;
				}
				for (int i = pos, j = 0; i < pos + len; i++, j++)
				{
					_str[i] = str[j];
				}

			}
			_size += len;
			_str[_size] = '\0';
			return *this;
		}

		//返回子串在字符串中出现的位置
		size_t string::find(const char* str, size_t pos)
		{
			assert(pos <= _size);
			size_t len = strlen(str);
			if (pos + len > _size)
				return npos;
			else
			{
				size_t fpos = find(str[0], pos);
				for (int i = fpos, j = 0; i < fpos + len; i++, j++)
				{


					if (str[j] != _str[i])
						return npos;

				}
				return fpos;
			}
		}
		string string::substr(size_t pos, size_t len)
		{
			assert(pos <= _size);
			string tmp;
			size_t end = pos + len;
			//if (len == npos || len >= _size - pos)
			//{
			//	tmp.reserve(_size - pos);
			//	strcpy(tmp._str, _str + pos);
			//	return tmp;

			//}
			//else
			//{
			//	memcpy(tmp._str, _str + pos, len);
			//	tmp[len] = '\0';
			//	return tmp;
			//}
			if (len == npos || len >= _size - pos)
			{
				end = _size;
			}
			tmp.reserve(end - pos);
			for (int i = pos; i < end; i++)
			{
				tmp += _str[i];
			}
			return tmp;
		}
		//	删除pos位置上的元素，并返回该元素的下一个位置

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


	ostream& operator<<(ostream& out, const string& s)
	{
		for (auto e : s)
		{
			out << e;
		}
		return out;
	}
	istream& operator>>(istream& in, string& s)
	{
		s.clear();
		char buff[128];
		char ch = in.get();
		int i = 0;
		while (ch != ' ' && ch != '\n')
		{
			buff[i] = ch;
			i++;
			if (i == 127)
			{
				buff[i] = '\0';
				s += buff;
				i = 0;
			}
			ch = in.get();
		}
		if (i > 0)
		{
			buff[i] = '\0';
			s += buff;
		}

		return in;
	}
	
}

三、Test.cpp

测试版本，对接口进行测试，写了三个测试版本，但并没有调用全部接口，进行一番演示，大致还行，可能还有错误，也是水平有限。 

#include "string.h"
namespace bit
{
	void stringtest1()
	{
		string s("hello world");

		string::iterator it = s.begin();
		while (it != s.end())
		{
			cout << *it;
			it++;
		}
		cout << endl;
		for (auto e : s)
		{
			cout << e;
		}
		cout << endl;
		string s1(s);
		string s2 = s1;
		for (auto e : s1)
		{
			cout << e;
		}
		cout << endl;
		for (auto e : s2)
		{
			cout << e;
		}
		cout << endl;

	}
	void stringtest2()
	{
		string s("hello world");
		s += "hello world";
		for (auto e : s)
		{
			cout << e;
		}
		cout << endl;

		string s1;
		s1.push_back('a');
		s1.push_back('b');
		s1.push_back('c');
		s1.push_back('d');
		for (auto e : s1)
		{
			cout << e;
		}
		cout << endl;
		cout << (s < s1);
		cout << (s > s1);
		cout << (s == s1);
		cout << (s <= s1);
		cout << (s >= s1);
		cout << true;
	};
	void stringtest3()
	{
		string s("hello world");
		string s1 = "excuse me";
		/*s.swap(s1);
		cout << s.c_str() << " " << s1.c_str() << endl;
		cout << s.capacity() << endl;
		s.reserve(100);
		cout << s.capacity() << endl;
		s.resize(5);
		cout << s.capacity() << " " << s.c_str() << endl;;*/
		//cout << s[0];
		size_t pos = s.find("world");
		cout << pos << endl;
		cout << s.substr().c_str() << endl;
		s.insert(0, 'w');
		cout << s.c_str() << endl;
		s.insert(6, 'e');
		cout << s.c_str() << endl;
		s1.insert(0, "hello");
		cout << s1.c_str() << endl;
		s1.insert(5, "hello");
		cout << s1.c_str() << endl;
		cin >> s1;
		cout << s1;

	}
}
int main()
{
	bit::stringtest1();
    bit::stringtest2();
    bit::stringtest3();
	return 0;
}

三个测试函数的输出结果 ：

 

 

 

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

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

相关文章

excel中批量插入分页符

excel中批量插入分页符

excel中批量插入分页符&#xff0c;实现按班级打印学生名单。 1、把学生按照学号、班级排序好。 2、选择班级一列&#xff0c;点击数据-分类汇总。汇总方式选择计数&#xff0c;最后三个全部勾选。汇总结果一定要显示在数据的下发&#xff0c;如果显示在上方&#xff0c;后期…
阅读更多...
RabbitMQ3.x之四_RabbitMQ角色说明及创建用户与授权

RabbitMQ3.x之四_RabbitMQ角色说明及创建用户与授权

RabbitMQ3.x之四_角色说明及创建用户与授权 文章目录 RabbitMQ3.x之四_角色说明及创建用户与授权1. 访问和授权1. Tags说明2. 命令行示例 2. 管理界面新建用户及访问授权1. 管理界面新建用户2. 管理界面中的授权说明3. guest用户不能远程登录提示 3. 创建用户1. 基本命令2. 实际…
阅读更多...
Unity 实现鼠标左键进行射击

Unity 实现鼠标左键进行射击

发射脚本实现思路 分析 确定用户交互方式&#xff1a;通过鼠标左键点击发射子弹。确定子弹发射逻辑&#xff1a;每次点击后有一定时间间隔才能再次发射。确定子弹发射源和方向&#xff1a;子弹从枪口&#xff08;Transform&#xff09;位置发射&#xff0c;沿枪口方向前进。 变…
阅读更多...
2024-3-28 市场情绪强修复

2024-3-28 市场情绪强修复

这一轮退潮负反馈都修复了&#xff0c; 艾艾精工 博信股份 安奈尔 永悦科技 大理药业 &#xff0c;高新发展 也补跌了&#xff0c;收尸队也干活了&#xff0c;情绪不修复不接力得最好写照。这轮周期 宁科生物 已经7板&#xff0c;已经追平了 博信股份7板&#xff0c;看明天溢…
阅读更多...
基于单片机产品数量自动计量智能系统设计

基于单片机产品数量自动计量智能系统设计

**单片机设计介绍&#xff0c;基于单片机产品数量自动计量智能系统设计 文章目录 一 概要二、功能设计设计思路 三、 软件设计原理图 五、 程序六、 文章目录 一 概要 基于单片机产品数量自动计量智能系统设计是一个融合了单片机技术、传感器技术和自动控制技术的综合性项目。…
阅读更多...
【Web应用技术基础】CSS(6)——使用 HTML/CSS 实现 Educoder 顶部导航栏

【Web应用技术基础】CSS(6)——使用 HTML/CSS 实现 Educoder 顶部导航栏

第一题&#xff1a;使用flex布局实现Educoder顶部导航栏容器布局 <!DOCTYPE html> <html lang"en"> <head><meta charset"UTF-8"><title>Educoder</title><script src"https://cdn.staticfile.org/jquery/1.1…
阅读更多...
Java与Go：字符串转IP

Java与Go：字符串转IP

在本文中&#xff0c;我们将了解如何将简单的对比Java和Go是如何将字符串解析为IP地址。 Java 在Java中&#xff0c;将字符串转换为IP地址最无脑的一个方法&#xff1a; import java.net.InetAddress; import java.net.UnknownHostException;public class Main {public stat…
阅读更多...
shell脚本发布docker springboot项目示例

shell脚本发布docker springboot项目示例

docker、git、Maven、jdk8安装略过。 使git pull或者git push不需要输入密码操作方法 约定&#xff1a; 路径&#xff1a;/opt/springbootdemo&#xff0c; 项目&#xff1a;springbootdemo&#xff0c; 打包&#xff1a;springbootdemo.jar&#xff0c; docker容器名字&#x…
阅读更多...
竞赛 python+opencv+深度学习实现二维码识别

竞赛 python+opencv+深度学习实现二维码识别

0 前言 &#x1f525; 优质竞赛项目系列&#xff0c;今天要分享的是 &#x1f6a9; pythonopencv深度学习实现二维码识别 &#x1f947;学长这里给一个题目综合评分(每项满分5分) 难度系数&#xff1a;3分工作量&#xff1a;3分创新点&#xff1a;3分 该项目较为新颖&…
阅读更多...
武汉星起航跨境电商：破局传统贸易，引领全球商业新风尚

武汉星起航跨境电商：破局传统贸易，引领全球商业新风尚

在全球经济格局日新月异的今天&#xff0c;跨境电商以其独特的商业模式和创新的运营理念&#xff0c;正在逐步改变着传统贸易的格局。武汉星起航电子商务有限公司&#xff0c;作为跨境电商领域的领军者&#xff0c;以其前瞻的战略布局和深厚的实战经验&#xff0c;不断推动着行…
阅读更多...
Java设计模式—备忘录模式（快照模式）

Java设计模式—备忘录模式（快照模式）

定义 备忘录模式提供了一种状态恢复的实现机制&#xff0c;使得用户可以方便地回到一个特定的历史步骤&#xff0c;当新的状态无效或者存在问题时&#xff0c;可以使用暂时存储起来的备忘录将状态复原&#xff0c;很多软件都提供了撤销&#xff08;Undo&#xff09;操作&#…
阅读更多...
基础算法-去重字符串,辗转相除法，非递归前序遍历二叉树题型分析

基础算法-去重字符串,辗转相除法，非递归前序遍历二叉树题型分析

目录 不同子串 辗转相除法-求最大公约数 二叉树非递归前序遍历 不同子串 从a开始&#xff0c;截取 a aa aaa aaab 从第二个下标开始a aa aab 从第三个 a ab 从第四个 b 使用set的唯一性&#xff0c;然后暴力遍历来去去重&#xff0c;从第一个下标开始截取aaab a aa aaa aaab…
阅读更多...
将html文件转化为pdf

将html文件转化为pdf

1.用浏览器将html文件打开 2.空白处右键点击打印 3.另存为PDF即可
阅读更多...
html音频和视频可输入表单input

html音频和视频可输入表单input

音频和视频 loop循环播放autoplay自动播放controls显示控制面板<audio src""> //<video src"#">muted静音播放 可输入表单input password密码框 radio单选框 checkbox复选框 file上传文件 text文本框 文本框<input type"text"…
阅读更多...
如何调试Clang源码

如何调试Clang源码

下载编译Clang 这个就直接去LLVM官网下载&#xff0c;然后编译好Clang就行&#xff0c;注意得debug模式&#xff0c;保存符号信息。 调试Clang 可以直接通过命令行来调试 #进入调试环境&#xff0c;这里的clang得是刚刚编译好的 lldb ./clang # r是运行&#xff0c;后面是正…
阅读更多...
Java认识泛型类

Java认识泛型类

一、包装类 认识泛型类之前先来认识一下包装类 1、基本数据类型和对应的包装类 在Java中&#xff0c;由于基本类型不是继承自Object&#xff0c;为了在泛型代码中可以支持基本类型&#xff0c;Java给每个基本类型都对应了一个包装类型。 除了 Integer 和 Character&#xff0…
阅读更多...
Python 基于 OpenCV 视觉图像处理实战 之 OpenCV 简单实战案例 之九 简单闪烁效果

Python 基于 OpenCV 视觉图像处理实战 之 OpenCV 简单实战案例 之九 简单闪烁效果

Python 基于 OpenCV 视觉图像处理实战 之 OpenCV 简单实战案例 之九 简单闪烁效果 目录 Python 基于 OpenCV 视觉图像处理实战 之 OpenCV 简单实战案例 之九 简单闪烁效果 一、简单介绍 二、简单闪烁效果实现原理 三、简单闪烁效果案例实现简单步骤 四、注意事项 一、简单…
阅读更多...
玩电脑突然停电对电脑有影响吗

玩电脑突然停电对电脑有影响吗

在现代社会中&#xff0c;电脑已成为我们日常生活和工作中不可或缺的一部分。然而&#xff0c;当我们正在专注于工作或娱乐时&#xff0c;突然停电可能会给我们带来不小的困扰。那么&#xff0c;玩电脑时突然停电会对电脑产生哪些影响呢&#xff1f;本文将深入探讨这一问题&…
阅读更多...
Groovy基础入门

Groovy基础入门

一、Groovy简介 Groovy是运行在JVM中的一种动态语言&#xff0c;可以在Java平台上进行编程&#xff0c;使用方式基本与使用Java代码的方式相同&#xff0c;它的语法与Java语言的语法很相似&#xff0c;与Java相比&#xff0c;Groovy更加灵活、简洁&#xff0c;而且完成同样的功…
阅读更多...
ChatGPT与传统搜索引擎的区别：智能对话与关键词匹配的差异

ChatGPT与传统搜索引擎的区别：智能对话与关键词匹配的差异

引言 随着互联网的快速发展&#xff0c;信息的获取变得比以往任何时候都更加便捷。在数字化时代&#xff0c;人们对于获取准确、及时信息的需求愈发迫切。传统搜索引擎通过关键词匹配的方式为用户提供了大量的信息&#xff0c;然而&#xff0c;这种机械式的检索方式有时候并不…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023