c++|string模拟实现

 

目录

一、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;
}

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

 

 

 

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

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

相关文章

面向对象的学习

面向对象的学习

封装 //用来描述一类事物的类&#xff0c;专业叫做&#xff1a;javabean类 //在javabean类是不写main方法的//一个java文件中可以定义多个类&#xff0c;且只能一个类是public修饰&#xff0c;而且public修饰的类名必须成为代码的文件名 ://在类中一般无需指定初始化值 存在默…
阅读更多...
C# OpenCvSharp 轮廓检测

C# OpenCvSharp 轮廓检测

目录 效果 代码 下载 效果 代码 using System; using System.Collections.Generic; using System.ComponentModel; using System.Data; using System.Drawing; using System.Linq; using System.Text; using System.Windows.Forms; using OpenCvSharp; using OpenCvSharp.…
阅读更多...
理解JVM：从字节码到程序运行

理解JVM：从字节码到程序运行

大家好&#xff0c;我是程序员大猩猩。 今天我们来讲一下JVM&#xff0c;好多面试者在面试的时候&#xff0c;都会被问及JVM相关知识。那么JVM到底是什么&#xff0c;要理解它到底是出于什么原因&#xff1f; JVM俗称Java虚拟机&#xff0c;它是一个抽象的计算机&#xff0c;…
阅读更多...
Hadoop面试重点

Hadoop面试重点

文章目录 1. Hadoop 常用端口号2.Hadoop特点3.Hadoop1.x、2.x、3.x区别 1. Hadoop 常用端口号 hadoop2.xhadoop3.x访问HDFS 端口500709870访问 MR 执行情况端口80888088历史服务器1988819888客户端访问集群端口90008020 2.Hadoop特点 高可靠&#xff1a;Hadoop底层维护多个数…
阅读更多...
京东电商实时数据采集：京东数据API接口海量数据采集京东商品详情页SKU实时采集

京东电商实时数据采集：京东数据API接口海量数据采集京东商品详情页SKU实时采集

京东数据api接口&#xff1a;京东电商数据如何采集&#xff1f; 用户行为日志采集 &#xff1a;这种方法通常用于记录用户在网站上的行为&#xff0c;如点击、浏览等&#xff0c;以帮助分析用户行为和优化用户体验。通用数据采集 &#xff1a;可以通过数据直通车等方式进行&am…
阅读更多...
数字孪生关键技术及体系架构

数字孪生关键技术及体系架构

摘要&#xff1a; 数字孪生以各领域日益庞大的数据为基本要素&#xff0c;借助发展迅速的建模仿真、人工智能、虚拟现实等先进技术&#xff0c;构建物理实体在虚拟空间中的数字孪生体&#xff0c;实现对物理实体的数字化管控与优化&#xff0c;开拓了企业数字化转型的可行思路…
阅读更多...
SpringBoot+Prometheus+Grafana实现应用监控和报警

SpringBoot+Prometheus+Grafana实现应用监控和报警

一、背景 SpringBoot的应用监控方案比较多&#xff0c;SpringBootPrometheusGrafana是目前比较常用的方案之一。它们三者之间的关系大概如下图&#xff1a; 关系图 二、开发SpringBoot应用 首先&#xff0c;创建一个SpringBoot项目&#xff0c;pom文件如下&#xff1a; <…
阅读更多...
本地部署大模型的几种工具（上-相关使用）

本地部署大模型的几种工具（上-相关使用）

目录 前言 为什么本地部署 目前的工具 vllm 介绍 下载模型 安装vllm 运行 存在问题 chatglm.cpp 介绍 下载 安装 运行 命令行运行 webdemo运行 GPU推理 ollama 介绍 下载 运行 运行不同参数量的模型 存在问题 lmstudio 介绍 下载 使用 下载模型文件…
阅读更多...
Git版本管理使用手册 - 8 - 合并分支、解决冲突

Git版本管理使用手册 - 8 - 合并分支、解决冲突

合并整个开发分支 切换到本地test分支&#xff0c;选择右下角远程开发分支&#xff0c;选择Merge into Current。然后提交到远程test仓库。 合并某次提交的代码 当前工作区切换成test分支&#xff0c;选择远程仓库中的dev开发分支&#xff0c;选择需要合并的提交版本右击&a…
阅读更多...
机器学习优化算法（深度学习）

机器学习优化算法（深度学习）

目录 预备知识 梯度 Hessian 矩阵&#xff08;海森矩阵&#xff0c;或者黑塞矩阵&#xff09; 拉格朗日中值定理 柯西中值定理 泰勒公式 黑塞矩阵&#xff08;Hessian矩阵&#xff09; Jacobi 矩阵 优化方法 梯度下降法&#xff08;Gradient Descent&#xff09; 随机…
阅读更多...
Hive-技术补充-ANTLR的真实语法世界

Hive-技术补充-ANTLR的真实语法世界

一、上下文 上一篇博客<Hive-技术补充-ANTLR语法编写>&#xff0c;我们了解了如何使用ANTLR语法来表达词法结构和语法结构&#xff0c;下面我们循循渐进的处理身边用过的一些文件或语言&#xff1a; CSV、JSON、DOT、Cymbol、R 二、解析CSV文件 有这样一份csv文件 …
阅读更多...
【详细讲解PostCSS如何安装和使用】

【详细讲解PostCSS如何安装和使用】

&#x1f308;个人主页:程序员不想敲代码啊&#x1f308; &#x1f3c6;CSDN优质创作者&#xff0c;CSDN实力新星&#xff0c;CSDN博客专家&#x1f3c6; &#x1f44d;点赞⭐评论⭐收藏 &#x1f91d; 希望本文对您有所裨益&#xff0c;如有不足之处&#xff0c;欢迎在评论区提…
阅读更多...
HarmonyOS 应用开发之UIAbility组件基本用法

HarmonyOS 应用开发之UIAbility组件基本用法

UIAbility组件的基本用法包括&#xff1a;指定UIAbility的启动页面以及获取UIAbility的上下文 UIAbilityContext。 指定UIAbility的启动页面 应用中的UIAbility在启动过程中&#xff0c;需要指定启动页面&#xff0c;否则应用启动后会因为没有默认加载页面而导致白屏。可以在…
阅读更多...
软件概要设计说明书word原件（实际项目）

软件概要设计说明书word原件（实际项目）

一、 引言 &#xff08;一&#xff09; 编写目的 &#xff08;二&#xff09; 范围 &#xff08;三&#xff09; 文档约定 &#xff08;四&#xff09; 术语 二、 项目概要 &#xff08;一&#xff09; 建设背景 &#xff08;二&#xff09; 建设目标 &#xff08;三&a…
阅读更多...
Jupyter开启远程服务器（最新版）

Jupyter开启远程服务器（最新版）

Jupyter Notebook 在本地进行访问时比较简单&#xff0c;直接在cmd命令行下输入 jupyter notebook 即可&#xff0c;然而notebook的作用不止于此&#xff0c;还可以用于远程连接服务器&#xff0c;这样如果你有一台服务器内存很大&#xff0c;但是呢你又不喜欢在linux上进行操作…
阅读更多...
【文本】正则 | 正则表达式收录

【文本】正则 | 正则表达式收录

1、匹配数字加右括号 1&#xff09;正则 \d\) 2&#xff09;效果 ~~
阅读更多...
探索多种数据格式：JSON、YAML、XML、CSV等数据格式详解与比较

探索多种数据格式：JSON、YAML、XML、CSV等数据格式详解与比较

title: 探索多种数据格式&#xff1a;JSON、YAML、XML、CSV等数据格式详解与比较 date: 2024/3/28 17:34:03 updated: 2024/3/28 17:34:03 tags: 数据格式JSONYAMLXMLCSV数据交换格式比较 1. 数据格式介绍 数据格式是用于组织和存储数据的规范化结构&#xff0c;不同的数据格…
阅读更多...
CSS(二)---【常见属性、复合属性使用】

CSS(二)---【常见属性、复合属性使用】

零.前言 本篇文章主要阐述CSS常见属性、复合属性&#xff0c;更多前置知识请见作者其它文章&#xff1a; CSS(一)---【CSS简介、导入方式、八种选择器、优先级】-CSDN博客 1.CSS属性 CSS的属性有上百个&#xff0c;但是我们并不需要全部学习&#xff0c;只要我们学习一部分…
阅读更多...
八大技术趋势案例（人工智能物联网）

八大技术趋势案例（人工智能物联网）

科技巨变，未来已来，八大技术趋势引领数字化时代。信息技术的迅猛发展，深刻改变了我们的生活、工作和生产方式。人工智能、物联网、云计算、大数据、虚拟现实、增强现实、区块链、量子计算等新兴技术在各行各业得到广泛应用，为各个领域带来了新的活力和变革。 为了更好地了解…
阅读更多...
UI的设计

UI的设计

一、RGB888的显示 即红色&#xff0c;绿色&#xff0c;蓝色都为8位&#xff0c;即通常说的24位色。可以很好显示各种过渡颜色。从硬件上&#xff0c;R、G、B三基色的连接线各需要有8根&#xff0c;即24根数据线&#xff1b;软件上存储的数据量也需要24位&#xff0c;即3个字节&…
阅读更多...
最新文章

Copyright @ 2022~2023