不会有人真的不看这个完整的string类实现，不会吧

最新推荐文章于 2024-05-29 20:12:04 发布
最新推荐文章于 2024-05-29 20:12:04 发布
阅读量284 收藏
点赞数 1
分类专栏： C++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Dly6161/article/details/106365026
版权

模拟实现一个string类，可以完成STL标准库中string类的大部分功能 。

基本函数实现：

构造函数、拷贝构造函数、operator赋值函数、析构函数

namespace Xner
{
	class string
	{
	public:
		string(const char* str = "")
		{
			_str = new char[strlen(str) + 1];
			strcpy(_str, str);
			_size = strlen(str);
			_capacity = _size;
		}
		
		string(const string& s)
		{
			_str = new char[strlen(s._str) + 1];
			strcpy(_str, s._str);
			_size = s._size;
			_capacity = s._capacity;
		}
		
		string& operator=(const string &s)
		{
			if (this != &s)
			{
				char* tmp = new char[strlen(s._str) + 1];
				strcpy(tmp, s._str);
				_size = s._size;
				_capacity = s._capacity;
				delete[] _str;
				_str = tmp;
			}
			return *this;
		}

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

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

迭代器、size( )、capacity( )、c_str( )、[ ] + index访问

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

		iterator end()
		{
			return _str + _size;
		}
		
		const char* c_str() const
		{
			return _str;
		}

		size_t size() const
		{
			return _size;
		}

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

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

reserve( )、resize( )、clear( )、empty( )

        void reserve(size_t newCapacity)
		{
			if (newCapacity > _capacity)
			{
				char* new_str = new char[newCapacity + 1];
				strcpy(new_str, _str);
				delete[] _str;
				_str = new_str;
				_capacity = newCapacity;
			}
		}

		void resize(size_t newSize, char c = '\0')
		{
			if (newSize < _size)
			{
				_str[newSize] = '\0';
				_size = newSize;
			}
			else
			{
				if (newSize > _capacity)
				{
					reserve(newSize);
				}

				for (size_t i = _size; i < newSize; ++i)
				{
					_str[i] = c;
				}
				_str[newSize] = '\0';
				_size = newSize;
			}
		}
		
		void clear()
		{
			_size = 0;
			_str[_size] = '\0';
		}
		
		bool empty() const
		{
			if (_size == 0)
				return true;
			return false;
		}

字符串比较大小

        bool operator<(const string& s)
		{
			int ret = strcmp(_str, s._str);
			return ret < 0;
		}

		bool operator<=(const string& s)
		{
			return *this < s || *this == s;
		}

		bool operator>(const string& s)
		{
			return !(*this <= s);
		}

		bool operator>=(const string& s)
		{
			return !(*this < s);
		}

		bool operator==(const string& s)
		{
			int ret = strcmp(_str, s._str);
			return ret == 0;
		}

		bool operator!=(const string& s)
		{
			return !(*this == s);
		}

push_back( )、append( )、+=字符/字符串

        void PushBack(char c)
		{
			if (_size == _capacity)
			{
				size_t newcapacity = _capacity == 0 ? 2 : _capacity * 2;
				reserve(newcapacity);
			}
			_str[_size] = c;
			++_size;
			_str[_size] = '\0';  
		}

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

		void Append(const char* str)
		{
			size_t len = strlen(str);
			if (_size + len > _capacity)
			{
				reserve(_size + len);
			}

			strcpy(_str + _size, str);
			_size += len;
		}

		string& operator+=(const char* str)
		{
			Append(str);
			return *this;
		}

find( )、insert( )、erase( )

        size_t find(char c, size_t pos = 0) const
		{
			for (size_t i = pos; i < _size; ++i)
			{
				if (_str[i] == c)
				{
					return i;
				}
			}
			return npos;
		}

		size_t find(const char* s, size_t pos = 0) const
		{
			char* p = strstr(_str, s);
			if (p == nullptr)
			{
				return npos;
			}
			else
			{
				return p - _str;
			}
		}
		
		string& insert(size_t pos, char c)
		{
			assert(pos <= _size);

			if (_size == _capacity)
			{
				size_t newcapacity = _capacity == 0 ? 2 : _capacity * 2;
				reserve(newcapacity);
			}

			int end = _size;
			while (end >= (int)pos)
			{
				_str[end + 1] = _str[end];
				--end;
			}
			_str[pos] = c;
			++_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);
			}

			int end = _size;
			while (end >= (int)pos)
			{
				_str[end + len] = _str[end];
				--end;
			}
			strncpy(_str + pos, str, len);
			_size += len;

			return *this;
		}

		string& erase(size_t pos, size_t len)
		{
			assert(pos < _size);

			if (len >= _size - pos)
			{
				_str[pos] = '\0';
				_size = pos;
			}
			else
			{
				size_t i = pos + len;
				while (i <= _size)
				{
					_str[i - len] = _str[i];
					++i;
				}

				_size -= len;
			}
			return *this;
		}
完整代码：
namespace Xner
{
	class string
	{
	public:
		//string s2("hello");
		string(const char* str = "")
		{
			_str = new char[strlen(str) + 1];
			strcpy(_str, str);
			_size = strlen(str);
			_capacity = _size;
		}

		//string s3(s2);
		string(const string& s)
		{
			_str = new char[strlen(s._str) + 1];
			strcpy(_str, s._str);
			_size = s._size;
			_capacity = s._capacity;
		}

		//s1 = s3
		string& operator=(const string &s)
		{
			if (this != &s)
			{
				char* tmp = new char[strlen(s._str) + 1];
				strcpy(tmp, s._str);
				_size = s._size;
				_capacity = s._capacity;
				delete[] _str;
				_str = tmp;
			}
			return *this;
		}

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

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

		iterator end()
		{
			return _str + _size;
		}

		//尾插字符
		void PushBack(char c)
		{
			if (_size == _capacity)
			{
				size_t newcapacity = _capacity == 0 ? 2 : _capacity * 2;
				reserve(newcapacity);
			}
			_str[_size] = c;
			++_size;
			_str[_size] = '\0';
		}

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

		//尾插字符串
		void Append(const char* str)
		{
			size_t len = strlen(str);
			if (_size + len > _capacity)
			{
				reserve(_size + len);
			}

			strcpy(_str + _size, str);
			_size += len;
		}

		string& operator+=(const char* str)
		{
			Append(str);
			return *this;
		}

		//清空字符串
		void clear()
		{
			_size = 0;
			_str[_size] = '\0';
		}

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

		size_t size() const
		{
			return _size;
		}

		size_t capacity() const
		{
			return _capacity;
		}

		//字符串判空
		bool empty() const
		{
			if (_size == 0)
				return true;
			return false;
		}

		void reserve(size_t newCapacity)
		{
			if (newCapacity > _capacity)
			{
				char* new_str = new char[newCapacity + 1];
				strcpy(new_str, _str);
				delete[] _str;
				_str = new_str;
				_capacity = newCapacity;
			}
		}

		void resize(size_t newSize, char c = '\0')
		{
			if (newSize < _size)
			{
				_str[newSize] = '\0';
				_size = newSize;
			}
			else
			{
				if (newSize > _capacity)
				{
					reserve(newSize);
				}

				for (size_t i = _size; i < newSize; ++i)
				{
					_str[i] = c;
				}
				_str[newSize] = '\0';
				_size = newSize;
			}
		}

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

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

		bool operator<(const string& s)
		{
			int ret = strcmp(_str, s._str);
			return ret < 0;
		}

		bool operator<=(const string& s)
		{
			return *this < s || *this == s;
		}

		bool operator>(const string& s)
		{
			return !(*this <= s);
		}

		bool operator>=(const string& s)
		{
			return !(*this < s);
		}

		bool operator==(const string& s)
		{
			int ret = strcmp(_str, s._str);
			return ret == 0;
		}

		bool operator!=(const string& s)
		{
			return !(*this == s);
		}

		//返回字符c在string中第一次出现的位置
		size_t find(char c, size_t pos = 0) const
		{
			for (size_t i = pos; i < _size; ++i)
			{
				if (_str[i] == c)
				{
					return i;
				}
			}
			return npos;
		}

		//返回子串s在string中第一次出现的位置
		size_t find(const char* s, size_t pos = 0) const
		{
			char* p = strstr(_str, s);
			if (p == nullptr)
			{
				return npos;
			}
			else
			{
				return p - _str;
			}
		}

		//在pos位置上插入字符c，并返回该字符的位置
		string& insert(size_t pos, char c)
		{
			assert(pos <= _size);

			if (_size == _capacity)
			{
				size_t newcapacity = _capacity == 0 ? 2 : _capacity * 2;
				reserve(newcapacity);
			}

			int end = _size;
			while (end >= (int)pos)
			{
				_str[end + 1] = _str[end];
				--end;
			}
			_str[pos] = c;
			++_size;

			return *this;
		}

		//在pos位置上插入字符串str，并返回该字符的位置
		string& insert(size_t pos, const char* str)
		{
			assert(pos <= _size);

			size_t len = strlen(str);
			if (_size + len > _capacity)
			{
				reserve(_size + len);
			}

			int end = _size;
			while (end >= (int)pos)
			{
				_str[end + len] = _str[end];
				--end;
			}
			strncpy(_str + pos, str, len);
			_size += len;

			return *this;
		}

		//删除pos位置上的元素
		string& erase(size_t pos, size_t len)
		{
			assert(pos < _size);

			if (len >= _size - pos)
			{
				_str[pos] = '\0';
				_size = pos;
			}
			else
			{
				size_t i = pos + len;
				while (i <= _size)
				{
					_str[i - len] = _str[i];
					++i;
				}

				_size -= len;
			}
			return *this;
		}

	private:
		char* _str;
		size_t _capacity;
		size_t _size;

		static size_t npos;
	};

	size_t string::npos = -1;  //静态成员变量要在类外初始化

	void Test_string()
	{
		string s1;
		cout << s1.size() << endl;
		cout << s1.capacity() << endl;

		string s2("hello");
		for (size_t i = 0; i < s2.size(); ++i)
		{
			cout << s2[i];
		}
		cout << endl;

		//拷贝构造
		string s3(s2);
		string::iterator s = s3.begin();
		while (s != s3.end())
		{
			cout << *s;
			++s;
		}
		cout << endl;

		//operator赋值
		s1 = s3;
		cout << s1.c_str() << endl;

		s1.PushBack(' ');   //尾插字符
		s1 += "world";   // +=字符串
		s1 += '!';   // +=字符
		s1.Append("123");   //尾插字符串
		cout << s1.c_str() << endl;
		s1.clear();   //清空字符串
		cout << s1.c_str() << endl;

		//在pos位置插入字符
		s1 += "abc";
		s1.insert(1, '1');
		s1.insert(0, 'x');
		cout << s1.c_str() << endl;
		//在pos位置插入字符串
		s1.insert(2, "abc");
		cout << s1.c_str() << endl;
		//在pos位置删除len个字符
		s1.erase(2, 1);
		cout << s1.c_str() << endl;
	}
}
运行结果：

在这里插入图片描述

Xn.er
关注
专栏目录
strlen函数以及string类使用心得
weixin_42427338的博客
05-11 3172
复习一下strlen函数 其实，给strlen函数之后它就会向下偏移统计个数，遇到当前位置字符为'\0'才会停下来。如果没有的话就有可能接着往下走下去，甚至会超过开辟空间的区域指向一片未开辟空间赋值的空间。 所以服务端这边接收的buffer要比需要接收的数据大小大一点才不会在strlen的时候出现问题，因为数组里面的数据都占满了，最后一个'\0'的位置没留下来，粗心大意。 函数原型 ...
20200509_实现string类
丰哥的专栏
05-09 167
20200509_实现string类 每日小知识 strlen有C版本和C++版本，C++版本需要头文件【cstring】。 一、相关术语 string类 C++处理字符串最常用的类，比C语言处理字符串的方法要更方便。 版本 VS使用VS2017，社区版本，15.9.13。 二、完整string类实现源码 头文件 #pragma once class wfstring { public: wfstring(const char* pData=nullptr); wfstring(const
【C++】模拟实现string类
C/C++领域,数据结构,linux,MySQl学习者
05-29 1090
使用C++语言模拟实现C++中的string类,包括string类中的成员变量,默认成员函数,成员函数,运算符重载以及迭代器. 是适合C++初学者的入门模拟实现string逐步详解.
java源代码之StringBuffer，StringBuilder，String类三个的关系
热爱编写程序的药学在读书
12-04 540
不看你绝对后悔 1、看String类的定义 （1）基本的定义 public final class String implements java.io.Serializable, Comparable<String>, CharSequence { private final char value[]; private int hash; // Default to 0 private static final long serialVersionU
【C++】string类的增删改查模拟实现（图例超详细解析！！！）
weixin_45031801的博客
04-25 1767
本模块呢，我将会带大家一起从 0~1去模拟实现一个STL库中的 string类，当然模拟实现的都是一些常用的接口，以便于让大家更好的巩固之前学习过的 缺省参数、封装、类中的6大默认成员函数等，代码量大概在 600行左右。
string模拟实现
weixin_50809457的博客
07-08 1023
strcmp能比较不同长度的字符串吗？可以，并且其中字符串提前结束后最后一位\0参与了对比，这和string里面的
边学边记——Java中的String类
lil_ghost_的博客
10-03 2267
当一个字符串的对象产生后，他的内容就无法修改，这称之为字符串常对象的不可变性。StringBuffer：线程安全，效率低，适用于10%需要保证线程安全的场景。StringBuilder：线程不安全，效率高，适用于90%的场景。
php 操作数据库类,PHP常用操作类实现——数据库操作类
weixin_34743057的博客
03-09 738
概述谢谢大家的收藏与赞，这是对我最大的鼓励。这一系列文章主要是一些PHP常用的类操作，回顾一下面向对象，我一直致力于小白文章的撰写，因为我也是小白，相信有人需要，希望读者能够喜欢。说明关于PHP语言实现各种操作类，网上都能够找得到，但是质量参差不齐，有的代码不好懂，有时候看的眼花缭乱，所以我在这里统一作了一个整理(注意：是整理，每一种操作类，我至少会参考三份优秀代码，然后自己跑出来，而不是CV)我...
使用BeanUtils.copyProperties工具类进行对象赋值copy时遇到的几个坑
tigerhhzz的博客
05-22 1212
如果我想看当前的这个属性是什么时候被设值值的时候，老猫的做法通常是找到当前的那个属性的set方法，然后使用idea中的“Find Usages”或者快捷键ALT+F7。得到需要属性值被设置的地方。这里简单分享一下，BeanUtils.copyProperties用户在两个对象之间进行属性的复制，底层基于JavaBean的内省机制，通过内省得到拷贝源对象和目的对象属性的读方法和写方法，然后调用对应的方法进行属性的复制。上面的代码中，我们看到基础属性的类型分别是包装类还有一个是非包装类，属性的命名都是一致的。
看完这篇还不会KMP算法,你打我
yhg_dh的博客
05-29 3033
看完这篇还不会KMP算法你打我 文章目录看完这篇还不会KMP算法你打我1.引入2.常规思路3.K.M.P算法==next数组的构成理解==指针j为什么可以回溯到k这个位置指针i为什么可以不移动？为什么需要next数组？那么我们怎么从next数组里面取出对应情况的k呢？为什么next[0] = -1 ; next[1] = 0 ;这两个数值是固定的呢？==next数组的获得==K.M.P算法实现 1.引入 ​ 这里有一个需求是这样的，我有一个字符串 s1 = “AABAA”,请找到子字符串"AB"在源字符串
分布式锁-这一篇全了解(Redis实现分布式锁完美方案)
热门推荐
Franco的博客
12-31 2万+
前言 在某些场景中，多个进程必须以互斥的方式独占共享资源，这时用分布式锁是最直接有效的。 随着技术快速发展，数据规模增大，分布式系统越来越普及，一个应用往往会部署在多台机器上（多节点），在有些场景中，为了保证数据不重复，要求在同一时刻，同一任务只在一个节点上运行，即保证某一方法同一时刻只能被一个线程执行。在单机环境中，应用是在同一进程下的，只需要保证单进程多线程环境中的线程安全性，通过 JAV...
java编写计算类加减乘除_老师要求张浩使用面向对象的思想编写一个计算器类(Calculator),可以实现两个整数的加减乘除的运算.java...
weixin_42468901的博客
02-23 3692
导航：网站首页 >老师要求张浩使用面向对象的思想编写一个计算器类(Calculator),可以实现两个整数的加减乘除的运算.java时间：2019-4-10老师要求张浩使用面向对象的思想编写一个计算器类(Calculator),可以实现两个整数的加减乘除的运算.java相关问题:匿名网友:要求直接能运行的么?再问： 能在my Eclipse运行的再答： 知道了,我给你写一个.大概10分钟左右...
devtools引发的一场关于类加载问题的探究
GitChat
10-26 939
本文适合有一定Java、JVM基础、了解一些thrift RPC序列化知识点；同时本文不会介绍类加载的基础知识，如双新委托、findClass|defineClass等； 通过本文你可以了解下面知识： ClassCastException异常的解决思路； devtools是如何使用类加载器来工作的； 强制类型转化与类加载器是如何关联上的； 美团mtthrift注解式的序列化与类加载器片面分...
小姐姐带你们偷偷的学Python，最后一天、Python的一些基础知识总结，不看比后悔系列，最后你们有没有惊艳所有人？
weixin_54707168的博客
02-15 201
小姐姐带你们偷偷的学Python，最后一天、Python的一些基础知识总结，不看比后悔系列，最后你们有没有惊艳所有人？
JAVA 按姓氏分类的电话薄（界面、方法的实现和讲解）
孤舟独饮不会醉
06-12 1105
老师又双叒叕留了大作业了，这次这个比较大，废了不少劲也掉了不少头发，虽然实现的方方有点笨，没有其他同学的漂亮，但还是写出来了，这个过程真是心酸有心累，还赶上期末，叫人抓狂，有两天晚上废了一晚上去找bug，还是没有找到，最后我舍友十分钟给找出来的. 当晚破防，我是伞兵，我是伞兵，我是伞兵。重要的事情说三遍。 如果要是想看实现的结果，直接将三个类CV一下到 idea 上就能编辑出来了，后边的就可以不看了，如果想看个个功能的实现方法和我遇到问题怎么解决的可以看后边，跳过代码，我看代码我也烦。 废话不在多说了，..
Windows系统远程桌面设置（附win11家庭版开启组策略功能及远程桌面）
最新发布
11-10
Windows系统远程桌面设置（附win11家庭版开启组策略功能及远程桌面）
一个兼容vue 2.x-3.x 的vue-seamless-scroll区域滚动插件
11-10
一个兼容vue 2.x-3.x 的vue-seamless-scroll区域滚动插件
名人堂网页源代码压缩包
11-10
我的目标是打造一个平台，让人们能够轻松地探索和学习那些对世界产生深远影响的杰出人物。
【信号检测】基于matlab自适应滤波法微弱信号检测【Matlab仿真 2308期】.zip
11-10
【信号检测】基于matlab自适应滤波法微弱信号检测【Matlab仿真 2308期】.zip
自定义C++ String类实现：构造、析构与运算符重载
"此资源是一个关于C++中自定义string类实现的代码示例，包括了构造函数、析构函数以及一些关键的操作符重载，如赋值运算符(=)、加法运算符(+)和等于运算符(==)。此外，还提供了访问字符串元素的下标运算符([])以及...
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值