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

最新推荐文章于 2024-05-29 20:12:04 发布
最新推荐文章于 2024-05-29 20:12:04 发布
阅读量263 收藏
点赞数 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
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
专栏目录
一个string类的简单实现案例
08-31
然而，有时候为了教学或理解目的，我们可能会自己实现一个简单的`string`类。以下是一个基于提供的代码的详细分析，介绍如何实现一个基本的`string`类。 首先，这个自定义的`String`类包含了几个重要的构造函数： ...
C++实现String类实例代码
08-30
主要介绍了C++实现String类实例代码的相关资料,需要的朋友可以参考下
strlen函数以及string类使用心得
weixin_42427338的博客
05-11 3149
复习一下strlen函数 其实，给strlen函数之后它就会向下偏移统计个数，遇到当前位置字符为'\0'才会停下来。如果没有的话就有可能接着往下走下去，甚至会超过开辟空间的区域指向一片未开辟空间赋值的空间。 所以服务端这边接收的buffer要比需要接收的数据大小大一点才不会在strlen的时候出现问题，因为数组里面的数据都占满了，最后一个'\0'的位置没留下来，粗心大意。 函数原型 ...
20200509_实现string类
丰哥的专栏
05-09 146
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 974
使用C++语言模拟实现C++中的string类,包括string类中的成员变量,默认成员函数,成员函数,运算符重载以及迭代器. 是适合C++初学者的入门模拟实现string逐步详解.
java源代码之StringBuffer，StringBuilder，String类三个的关系
热爱编写程序的药学在读书
12-04 528
不看你绝对后悔 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
边学边记——Java中的String类
lil_ghost_的博客
10-03 1600
当一个字符串的对象产生后，他的内容就无法修改，这称之为字符串常对象的不可变性。StringBuffer：线程安全，效率低，适用于10%需要保证线程安全的场景。StringBuilder：线程不安全，效率高，适用于90%的场景。
【C++】string类的增删改查模拟实现（图例超详细解析！！！）
weixin_45031801的博客
04-25 1640
本模块呢，我将会带大家一起从 0~1去模拟实现一个STL库中的 string类，当然模拟实现的都是一些常用的接口，以便于让大家更好的巩固之前学习过的 缺省参数、封装、类中的6大默认成员函数等，代码量大概在 600行左右。
php 操作数据库类,PHP常用操作类实现——数据库操作类
weixin_34743057的博客
03-09 721
概述谢谢大家的收藏与赞，这是对我最大的鼓励。这一系列文章主要是一些PHP常用的类操作，回顾一下面向对象，我一直致力于小白文章的撰写，因为我也是小白，相信有人需要，希望读者能够喜欢。说明关于PHP语言实现各种操作类，网上都能够找得到，但是质量参差不齐，有的代码不好懂，有时候看的眼花缭乱，所以我在这里统一作了一个整理(注意：是整理，每一种操作类，我至少会参考三份优秀代码，然后自己跑出来，而不是CV)我...
使用BeanUtils.copyProperties工具类进行对象赋值copy时遇到的几个坑
tigerhhzz的博客
05-22 902
如果我想看当前的这个属性是什么时候被设值值的时候，老猫的做法通常是找到当前的那个属性的set方法，然后使用idea中的“Find Usages”或者快捷键ALT+F7。得到需要属性值被设置的地方。这里简单分享一下，BeanUtils.copyProperties用户在两个对象之间进行属性的复制，底层基于JavaBean的内省机制，通过内省得到拷贝源对象和目的对象属性的读方法和写方法，然后调用对应的方法进行属性的复制。上面的代码中，我们看到基础属性的类型分别是包装类还有一个是非包装类，属性的命名都是一致的。
看完这篇还不会KMP算法,你打我
yhg_dh的博客
05-29 2758
看完这篇还不会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"在源字符串
看完这一篇你还不会JavaWeb吗
hello_list的博客
05-31 684
相信我看完这一篇你不可能还不会JavaWeb，小伙伴们大学实训的时候，会有过javaweb实训吧，反正我们那是，在没学习各大框架之前，我们都是学习javaweb的原生操作，相信原生基础好了，后面框架无非是提供便利，所以这里对javaweb的知识做一个个人小总结，这里就开始分段去更新了，希望小伙伴可以跟上，只要跟上了，那就可以说可以了，趋于保姆级教程了，所以希望对你有帮助，那看到这里先给博主点个赞吧，看完你再决定关不关注下博主； javaweb就是写服务端小程序嘛，我们知道前台没办法写j
C++ string类的隐式共享写时拷贝的实现及设计要点
12-22
　试想一下，如果我们要自己实现一个string类，简单的方式是什么？是让每一个string类的实例维护一个在内存中独立的字符数组，每个string对象各不相干。这样一个对象的任何变化都不会影响到其他的对象。这样做的...
C++简单String类的实现
12-22
但也只是看看，还没来得及自己写一个)于是自己写了一个简易的string类，也算对之前学到的部分知识一个小小的汇总，string类也是很考研小白的内存管理的，这个String类也是我调试了很多遍后没啥问题才敢发出来的，...
聚类算法-一种无监督学习方法.docx
最新发布
08-12
聚类算法是一种无监督学习方法，用于将数据集中的数据点自动分组到不同的类别中，这些类别也称为“簇”或“群”。聚类的目标是让同一簇内的数据点尽可能相似，而不同簇之间的数据点尽可能不相似。聚类算法广泛应用于多种领域，如数据挖掘、模式识别、图像分析、信息检索等。 聚类算法的基本概念 无监督学习：聚类算法不需要事先标记数据点的类别标签，而是根据数据本身的相似性来分组。 相似性度量：聚类算法依赖于某种相似性或距离度量来决定数据点之间的相似程度。常用的度量包括欧氏距离、曼哈顿距离等。 目标函数：大多数聚类算法都会尝试最小化某种目标函数，例如簇内的平方误差和（SSE）。 常见的聚类算法 K-Means K-Means 是一种原型聚类算法，它通过迭代地将数据点分配到最近的质心来形成簇，并重新计算每个簇的质心，直到质心不再显著变化为止。 在 Python 的 scikit-learn 库中，可以通过 KMeans 类实现 K-Means 聚类。 层次聚类 层次聚类构建一个树状图（称为树状图或 dendrogram），显示数据点是如何逐渐合并成簇的。 这种算法可以是凝聚型（自底向上）或分裂型（自顶向下）。
45ft集装箱模型3D图纸 STEP格式.zip
08-12
45ft集装箱模型3D图纸 STEP格式.zip
Spring Boot网吧管理系统.zip
08-12
该系统严格按照需求分析制作相关模块，并利用所学知识尽力完成，但是本人由于学识浅薄，无法真正做到让该程序可以投入市场使用，仅仅简单实现部分功能，希望日后还能改善。 本系统具有以下优点： 该系统具有较高的适用性，选用B/S结构，可以在绝大部分个人平台上使用该系统。 系统将用户权限进行划分，管理员，网管和会员都能看到及操作的信息不一样，三者具备不同的操作权限。 该系统操作界面简单明了，大部分人都可以正常使用。 但也存在以下问题需要改进： 运行时窗口不能被刷新，可以改进。 系统过于简单，显示的信息有限。。 不能添加多个管理员账号，如果可以则将利于发展网吧规模，便于网吧信息集中管理。 不能实时预约接待消息和网吧反馈建议，容易被忽视，不利于管理员服务客户。
微信小程序大作业 新闻小程序
08-12
微信小程序大作业 新闻小程序
一种简单易用的通用循环队列的C语言解决方案
08-12
博文《一种简单易用的通用循环队列的C语言解决方案》实现的代码。 在实际的嵌入式编程中，消息队列的使用还是比较频繁的，已经在文章《一种简单安全的消息队列的C语言解决方案》中说明了一种队列的解决方案，但是那种设计其中还是存在一些不方便的用法，对于嵌入式系统中一些要求或者性能限制下，可能会用到循环队列，但是对于不使用操作系统的情况下，队列相关的功能就需要手动实现。所以下面将会介绍一种简单的循环队列的实现方式。
C++自定义String类详解与实现
在C++编程中，自己实现一个类似于标准库中的String类，如CString，是一种重要的实践...这个文档提供了一个动手实现C++ String类的实例，通过实际操作，程序员能够锻炼自己的编程技巧，增强对C++特性的理解和应用能力。
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值