c++ string类（模拟实现）

最新推荐文章于 2024-10-02 15:47:04 发布
最新推荐文章于 2024-10-02 15:47:04 发布
阅读量89 收藏
点赞数
分类专栏： 学习笔记 文章标签： c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_42517365/article/details/104395720
版权 
#include <iostream>
#include <String>
#include<assert.h>
#pragma warning(disable:4996)
using namespace std;

namespace bit
{
	class string
	{
		friend ostream& operator<<(ostream& out, const string& s);
		friend istream& operator>>(istream& in, string& s);
	public:
		static const size_t npos = -1;
	public:
		string(const char* s = "") :m_str(nullptr)
		{
			m_capacity = m_size = strlen(s);
			m_str = new char[m_capacity + 1];
			strcpy(m_str, s);
		}
		string(const string& s) :m_str(nullptr), m_size(0), m_capacity(0)
		{
			string tmp(s.m_str);
			_swap(tmp, *this);
		}
		string& operator=(const string& s)
		{
			if (this != &s)
			{
				string tmp(s);
				_swap(tmp, *this);
			}
			return *this;
		}
		~string()
		{
			if (m_str)
			{
				delete[]m_str;
				m_str = nullptr;
			}
			m_size = 0;
			m_capacity = 0;
		}
	public:
		int size()const
		{
			return m_size;
		}
		int capacity()const
		{
			return m_capacity;
		}
		bool empty()const
		{
			return m_size == 0;
		}
		void clear()
		{
			m_size = 0;
			m_str[0] = '\0';//第一个下标填入结束标志符
		}
		const char* c_str() const
		{
			return m_str;
		}
	public:
		typedef char* iterator; //模拟迭代器
		iterator begin()
		{
			return m_str;
		}
		iterator end()
		{
			return m_str + m_size;
		}
	public:
		void push_back(char x)
		{
			if (m_size >= m_capacity)
			{
				reserve(m_capacity * 2);
			}
			m_str[m_size++] = x;
			m_str[m_size] = '\0';
		}
		void reserve(int new_cpy)
		{
			if (new_cpy > m_capacity)//新容量>目前容量才会扩容
			{
				//扩容之后，m_str之前所存的内容仍要存在
				char* new_str = new char[new_cpy + 1];
				memcpy(new_str, m_str, m_size + 1);
				//mecpy(目标，要复制的数据源，要复制的大小个数(包括\0，所以加一))；
				m_capacity = new_cpy;
				delete[]m_str;    //m_str[0]='\0';
				m_str = new_str;
			}
		}
	public:
		string& operator+=(char c) //追加一个字符
		{
			push_back(c); //插入一个字符
			return *this;
		}
		void append(const char* str) //追加字符串
		{
			int str_len = strlen(str);
			if (m_size + str_len > m_capacity)//容量不够追加时，扩容
			{
				reserve((m_size + str_len) * 2);
			}
			memcpy(m_str + m_size, str, sizeof(str));
			m_size = m_size + str_len;
			m_str[m_size] = '\0';
		}
		string& operator+=(const char* str)
		{
			append(str);
			return *this;
		}
		void resize(int newSize, char c = '\0')//调整大小为newSize,且填充字符c
		{
			if (newSize > m_size)  //调整后的大小>原大小时：
			{
				if (newSize > m_capacity) //（1）调整后的大小>容量时，需扩容
				{
					reserve(newSize * 2);
				}
				//将调整后相较于原大小多出的空间将其填充字符c，用memset进行初始化即可
				//memset(起始位置，字符c，size) ：从起始位置开始初始化为字符c，共初始化size个大小
				memset(m_str + m_size, c, newSize - m_size);
			}
			m_size = newSize;
			m_str[m_size] = '\0';
		}
		char& operator[](int i)
		{
			assert(i < m_size && i >= 0);
			return m_str[i];
		}
		const char& operator[](int i)const
		{
			assert(i >= 0 && i < m_size);
			return m_str[i];
		}
		bool operator<(const string& s)
		{
			return (strcmp(m_str, s.m_str) < 0);
		}
		bool operator>(const string& s)
		{
			return (strcmp(m_str, s.m_str) > 0);
		}
		bool operator<=(const string& s)
		{
			return !(*this > s);
		}
		bool operator>=(const string& s)
		{
			return !(*this < s);
		}
		bool operator==(const string& s)
		{
			return (strcmp(m_str, s.m_str) == 0);
		}
		bool operator!=(const string& s)
		{
			return !(*this == s);
		}
	public:

		// 返回c在string中第一次出现的位置
		size_t find(char c, size_t pos = 0) const
		{
			for (size_t i = pos; i < m_size; i++)
			{
				if (m_str[i] == c)
				{
					return i;
				}
			}
			return npos;
		}
		// 返回子串s在string中第一次出现的位置
		size_t find(const char* s, size_t pos = 0) const
		{
			size_t i = pos, j = 0, s_len = strlen(s);
			while (i < m_size && j < s_len)
			{
				if (m_str[i] == s[j])
				{
					i++;
					j++;
				}
				else
				{
					i = i - j + 1; //回溯到查找的下一个位置
					j = 0;
				}
			}
			if (j >= s_len)
			{
				return i - j; //返回的是子串在主串中的第一个字符位置
			}
			return npos;
		}
		// 在pos位置上插入字符c/字符串str，并返回该字符的位置
		string& insert(size_t pos, char c)
		{
			if (m_size + 1 > m_capacity)
				reserve((m_size + 1) * 2);
			for (size_t i = m_size; i > pos; i--)
			{
				m_str[i] = m_str[i - 1];//右移
			}
			m_str[pos] = c;
			m_size = m_size + 1;
			m_str[m_size] = '\0';
			return *this;
		}
			// 删除从pos位置起的len个元素，并返回该元素的下一个位置
		string& erase(size_t pos, size_t len = 1)
		{
			for (size_t i = pos + len; i < m_size; i++)
			{
				m_str[i - len] = m_str[i]; //左移
			}
			m_size -= len;
			m_str[m_size] = '\0';
			return *this;
		}
	protected:
		static void _swap(string& s1, string& s2) //交换要用引用or指针！！！
		{
			std::swap(s1.m_str, s2.m_str);
			std::swap(s1.m_capacity, s2.m_capacity);
			std::swap(s1.m_size, s2.m_size);
		}

	private:
		char* m_str;
		int m_size;
		int m_capacity;
	};
	ostream& operator<<(ostream& out, const string& s)
	{
		out << s.m_str;
		return out;
	}
	istream& operator>>(istream& in, string& s)
	{
		static size_t default_buf_size = 5; //默认开辟大小为5的空间存放，当超过大小后自动增长
		int count = 0;//存入的字符数，
		int capacity = default_buf_size;
		char* str = (char*)malloc(sizeof(char) * capacity);
		char* buf = str;
		//getchar()获取一个字符，获取完会自动走向下一个、
		while((*buf = getchar()) == ' ' || *buf == '\n');//跳过最开始的空格和换行符
		for (;;)
		{
			if (*buf == ' ' || *buf == '\n')
			{
				*buf = '\0';
				break;
			}
			else if (count+1>= capacity)//当输入的字符数超过默认大小时，自动增长空间
			//由于先加加指针才存入内容，故当buf指针指向最后一个位置时，此时再想存入字符时，buf仍要先++,但此时越界
			//且当前count=capacity-1；所以当count+1>=capapcity时要扩容
			{
				capacity *= 2;
				str = (char*)realloc(str, capacity);//在str追加开辟capacity空间
				buf = str + count ;//重新定位buf位置
			}
			++buf;//先加加指针，
			*buf = getchar();//再存入字符
			count++;
		}
		s.m_capacity = capacity;
		s.m_size = count;
		delete[]s.m_str;
		s.m_str = str;
		return in;
	}
}
int main()
{
	bit::string s1;
	cout << "构造函数s1：" << s1 << endl;
	bit::string s2("C+");
	cout << "构造函数s2：" << s2 << endl;
	bit::string s3(s2);
	cout << "拷贝构造s3：";
	for (int i = 0; i < s3.size(); i++)
		cout << s3[i];
	cout << endl;
	const char* str = s3.c_str();

	bit::string s4;
	s4 = s3;
	cout << "赋值函数s4：" << s4 << endl;
	bit::string::iterator it = s4.begin();
	cout << "迭代器打印s4：";
	while (it != s4.end() - 1)
	{
		cout << *it;
		it++;
	}
	cout << endl;
	s4.clear();
	cout << "清理s4:" << s4 << endl;
	if (s4.empty())
	{
		cout << "s4为空" << endl;
	}
	else
	{
		cout << "s4不空" << endl;
	}
	s4.push_back('x');
	s4.push_back('t');
	s4.push_back('t');
	cout << "插入3个元素：" << s4 << "  s4.m_capacity:" << s4.capacity() << "  s4.m_size:" << s4.size() << endl;
	s4.reserve(5);
	cout << s4 << "  s4.m_capacity:" << s4.capacity() << "  s4.m_size:" << s4.size() << endl;
	s4.append("123");
	cout << "追加s4:" << s4 << "  s4.m_capacity:" << s4.capacity() << "  s4.m_size:" << s4.size() << endl;
	s4 += "56";
	cout << "+=(字符串) s4:" << s4 << "  s4.m_capacity:" << s4.capacity() << "  s4.m_size:" << s4.size() << endl;
	s4.resize(13, 'o');
	cout << "调整大小 s4:" << s4 << "  s4.m_capacity:" << s4.capacity() << "  s4.m_size:" << s4.size() << endl;
	bit::string s5 = ("helhlo");
	bit::string s6 = ("hellohel");
	if (s5 > s6)
		cout << "s5>s6" << endl;
	else if (s5 < s6)
		cout << "s5<s6" << endl;
	else
		cout << "s5==s6" << endl;
	size_t pos = s5.find('h', 1);
	cout << "查找字符 s5：" << pos << endl;
	size_t pos1 = s6.find("hel", 6);
	cout << "查找字符串(模式匹配) s6：" << pos1 << endl;
	bit::string s7 = "1234";
	cout << s7 << "  s7.m_capacity: " << s7.capacity() << "  s7.m_size:" << s7.size() << endl;
	s7.insert(0, '5');
	cout << "按位置插入1个字符 s7: " << s7 << "  s7.m_capacity: " << s7.capacity() << "  s7.m_size:" << s7.size() << endl;
	s7.erase(0, 2);
	cout << "按位置删除len个字符 s7: " << s7 << "  s7.m_capacity: " << s7.capacity() << "  s7.m_size:" << s7.size() << endl;
	bit::string s8;
	cin >> s8;
	cout <<"cin s8: "<< s8 << endl;
	return 0;
}


//=====================================================================================================================
//现代写法模拟string类
利用了临时对象的思想，进行原有空间的释放
/*class String
{
	friend ostream& operator<<(ostream& out, const String& s);
public:
	String(const char* s = "")
	{
		m_str = new char[strlen(s) + 1];
		strcpy(m_str, s);
	}
	String(const String &s):m_str(nullptr)//拷贝构造先把要拷贝的初始化
	{
		String tmp(s.m_str);
		//申请一个临时类空间，由字符串(要复制的类的字符串指针)构造类tmp，
		//然后把要复制的类内容与这个临时类内容交换，
		//拿到复制内容与临时类的地址，这是为了防止多次释放同一空间所造成运行崩溃
		std::swap(tmp.m_str, m_str);
	}
	String& operator=(const String s)
	{
		if (&s != this) //判断两个类是否相等，可判断首地址是否相等
		{
			String tmp(s);
			std::swap(tmp.m_str, m_str);
		}
		return *this;
	}
	~String()
	{
		if (m_str != nullptr)
		{
			delete[]m_str;
			m_str = nullptr;
		}
	}
private:
	char* m_str;
};
ostream& operator<<(ostream& out, const String& s)
{
	out << s.m_str;
	return out;
}
int main()
{
	String s1="123"; //由字符串创建对象，即用构造函数
	cout << s1 << endl;
	String s2("hello"); //由字符串创建对象，即用构造函数
	cout << s2 << endl;
	String s3(s2);     //调用拷贝构造创建对象
	cout << s3 << endl;
	String s4 = s3;   //调用拷贝构造创建对象
	cout << s4 << endl;
	String s5;
	s5 = s4; //调用赋值函数
	cout << s5 << endl;
	return 0;
}*/

//====================================================================================================================
//传统模拟string类
/*class String
{
public:
	friend ostream& operator<<(ostream &out,const String &s);
public:
	String(const char* str = " ")
	{
		m_str = new char[strlen(str) + 1];//加一加的是最后的/0
		strcpy(m_str, str);
	}
	String& operator=(String s)
	{
		if (this != &s)
		{
			char* p = new char[strlen(s.m_str) + 1];
			//重新申请一块空间复制s，这是为了防止浅赋值所造成的对一块空间多次释放的问题。
			strcpy(p, s.m_str);
			delete[]m_str;
			m_str = p;
		}
		return *this;
	}
	String(const String& s)
	{
		m_str = (new char[strlen(s.m_str) + 1]);
		strcpy(m_str, s.m_str);
	}
	~String()
	{
		delete[]m_str;
		m_str = nullptr;
	}
private:
	char* m_str;
};
ostream& operator<<(ostream& out, const String &s)
{
	out << s.m_str;
	return out;
}
int main()
{
	String s1="hello";
	cout << s1 << endl;
	String s2(s1);
	cout << s2 << endl;
	String s3=s2;
	cout << s3 << endl;
	return 0;
}*/

/*---------------------------------------------------------------------------------------------------------------------/*
int main()
{
	String str = "Hello Bit.";
	String::iterator it = str.begin();
	while (it != str.end())
	{
		if (*it != ' ')
			cout << *it;
		else
			str.erase(it);
		it++;
	}*/


	/*String strText = "How are you?";
	String strSeparator = " ";
	String strResult;
	int size_pos = 0;
	int size_prev_pos = 0;
	while ((size_pos = strText.find_first_of(strSeparator, size_pos)) != String::npos)
	{
		strResult = strText.substr(size_prev_pos, size_pos - size_prev_pos);
		cout << strResult << " ";
		size_prev_pos = ++size_pos;
	}
	if (size_prev_pos != strText.size())
	{
		strResult = strText.substr(size_prev_pos, size_pos - size_prev_pos);
		cout << strResult << " ";
	}
	cout << endl;*/

	/*String a = "hello world";
	String b = a;
	if (a.c_str() == b.c_str())
	{
		cout << "true" << endl;
	}
	else
		cout << "false" << endl;
	String c = b;
	c = "";
	if (a.c_str() == b.c_str())
	{
		cout << "true" << endl;
	}
	else
		cout << "false" << endl;
	a = "";
	if (a.c_str() == b.c_str())
	{
		cout << "true" << endl;
	}
	else
		cout << "false" << endl;
	return 0;
}*/
带佩亚诺余项的泰勒
关注
专栏目录
C++ string类模拟实现
qq_64105689的博客
09-09 1143
1.创建string类 2.默认成员函数的模拟实现 2.1 Constructor(构造函数) 函数实现： 2.2 Destructor(析构函数) 函数实现： 2.3 拷贝构造函数 函数实现： 2.4 Operator=(赋值运算符的重载) 函数实现： 测试代码： 3.Capacity(容量) 函数实现： 测试代码： 4.Element access(元素访问) 测试代码： 5.Iterators(迭代器) 函数实现： 测试代码： 6.Madifiers(修
CString 与string 以及char之间的转换
bitsjx的专栏
06-11 1091
还是用代码说话吧。看看下面这这段代码，里面涉及到了CString 与string 以及char之间的转换。void CManageDlg::ReadFromRecord() { ifstream in; in.open("./url//record.txt",ios::in); string tempbuf=""; int nIndex=0; char buf[256]; while(in.getline(buf,256)) { tempbuf=(string)buf
C与C++中的字符数组char*和字符串string的相互转化
blink_cao的博客
01-30 275
1. 将字符数组char[]转化为字符串string char ch [] = “ABCDEFG”; string str(ch);//也可string str = ch; //或者 char ch [] = “ABCDEFG”; string str; str = ch;//在原有基础上添加可以用str += ch; 2. 将字符串string转化为字符数组char[] char b...
c/c++各种字符、字符串类型转换
u012248410的专栏
12-20 1082
CString 是一种很特殊的 C++ 对象，它里面包含了三个值：一个指向某个数据缓冲区的指针、一个是该缓冲中有效的字符记数(它是不可存取的，是位于 CString 地址之下的一个隐藏区域)以及一个缓冲区长度。 有效字符数的大小可以是从0到该缓冲最大长度值减1之间的任何数（因为字符串结尾有一个NULL字符）。字符记数和缓冲区长度被巧妙隐藏。 (1) char*转换成CString 　　
模拟实现string类
qq_54178958的博客
04-12 332
模拟实现string，包含增删查改等功能。 mystring.h #pragma once #define _CRT_SECURE_NO_WARNINGS #include <iostream> #include <assert.h> #include <string.h> using std::ostream; using std::istream; namespace bit { class string { friend ostream&
C++string类模拟实现
weixin_59112191的博客
04-27 1608
ssssss
第10课-C++ string 类模拟实现
最新发布
2401_83603768的博客
10-02 1477
整型和枚举类型的 const 静态成员变量可以在类内初始化，因为它们是编译时常量，编译器可以直接替换为常量值。复杂类型（如 double 或对象类型）需要在类外初始化，因为这些类型的初始化可能依赖运行时的条件或动态内存分配。这是 C++ 设计者在保证效率和复杂性之间做出的权衡，允许简单类型进行编译时优化，但要求复杂类型在类外显式初始化，以确保其初始化的灵活性和正确性。
c++模拟实现string类
北川_的博客
01-11 1864
目录string类简介模拟实现成员变量成员函数构造函数拷贝构造赋值重载析构函数迭代器普通迭代器const迭代器重载运算符[ ]代码 string类简介 标准库类型string表示可变长的字符序列，使用string类型必须首先包含string头文件。作为标准库的一部分，string定义在命名空间std中。 模拟实现 成员变量 char* _str; size_t _size; size_t _capacity; //不包含最后做标识的'\0' static const size_t npos; _s
C++ —— 模拟实现string类
weixin_59913110的博客
11-07 1539
本篇博客分享了笔者如何模拟实现string类的过程。其中包括最常用、最实用的接口。例如流插入、提取运算符重载、下标运算符重载、常用的构造函数、析构函数……
C++ string类的实现
m0_60447315的博客
08-21 3344
C++ string类实现
C++ string类的模拟实现
08-11
C++ string类的模拟实现
详解C++中String类模拟实现以及深拷贝浅拷贝
08-28
然而，为了更好地理解这一封装的实现原理，开发者有时需要模拟实现一个String类。在这模拟实现的过程中，必须处理深拷贝（deep copy）和浅拷贝（shallow copy）的问题。 浅拷贝在对象复制时，仅仅是复制了对象的...
C++中string类的模拟实现
02-23
该资源中模拟实现了C++中string类的一些常用接口，包括resize、reserve、insert、erase等等，重载了流插入和流提取操作符以实现对string类对象的输出和输入。其中还关注了深拷贝的问题（由于string类中涉及内存资源...
用matlab实现用Bp神经网络对iris数据集进行分类（以及影响分类性能的参数条件）
热门推荐
qq_42517365的博客
11-05 2万+
一、实验内容 Iris鸢尾花卉数据集，是一类多重变量分析的数据集。数据集包含150个数据样本，分为3类，每类50个数据，每个数据包含4个属性，分别对应花萼长度，花萼宽度，花瓣长度，花瓣宽度。 本次实验目的是用Bp神经网络对iris数据集进行分类，并进行分析。 二、实验过程 1.将数据集加载到工作区：load iris.dat; 2.数据预处理 （1）将原始iris数据集随机抽取118行作为训练数...
蚁群算法解决TSP问题（C++编写，附全代码）
qq_42517365的博客
12-07 6590
1.Tsp问题描述 有N个城市，C={0,1,2,3…,N-1}，任意两城市距离为dij，求一条经过每个城市的路径，使得距离最小。以30个城市为例分析，另代码中50和75个城市同理。 2. 参数设置 N：城市个数30 M：蚂蚁个数30 a：表征信息素重要程度的参数，设为2 b：表征能见度重要程度的参数，设为3 p：局部信息素挥发参数，设为0.1 r: 全局信息素挥发参数，设为0.1 NC_MA...
一种基于分解的多目标优化算法：MOEA/D
qq_42517365的博客
04-20 2882
实验目的 实验的主要目的是对测试函数ZDT1用MOEA/D算法得到最佳帕累托解集。 帕累托解 在约束空间之内，再也找不到比解A更好的解了，那么A就是其中一个帕累托最优解。 ZDT1测试函数 是一个两目标问题，其函数如下： MOEA/D算法思想 MOEA/D是一种基于分解的多目标进化算法，它将多目标优化问题转化为一系列单目标优化子问题，然后利用一定数量相邻问题的信息，采用进化算法对这些子问题同时进...
八数码问题的启发式搜索方法__A*搜索
qq_42517365的博客
10-15 1599
八数码问题： 在3×3棋盘上，放有1到8八个数码，有1个方格是空的，空位置用0表示，对空格依次执行左移、右移、上移和下移这四个操作，使得棋盘从初始状态到目标状态。本次实验中以如下初始状态和目标状态为例： 1.基本思路 本次启发式搜索是在广度优先遍历的基础上给出启发信息的搜索，然后在每一层结点中利用启发信息找一个最优结点，然后在这个最优结点的基础上再扩展下一层，重复上述操作，直到找到目标结点。 启...
计算机网络---加密解密ssl
qq_42517365的博客
12-16 462
1.对称加密 对称加密技术分为两种：流密码（用于无线LAN的安全性）、块密码（多用于因特网协议的加密，比如ssl用于tcp连接安全性，PGP用于安全电子邮件） 1.1 块密码 1.1.1 块密码密文如何生成？ 对要加密的报文进行分块，每一块都被分为了k个比特位，然后对每一块进行独立加密，采取一对一映射，即k比特明文被映射为k比特密文。 那么对于一个2比特明文来说，它的一种明文到密文的映射表可以是： 输入 输出 00 01 01 10 10 11 11 00 对于这样一种生成密
mysql（四）==》事务、并发、死锁
qq_42517365的博客
12-16 420
1.事务与并发控制 1.什么是事务？ 事务是数据库执行的最小逻辑单元 事务可以由一个sql组成，也可以由多个sql组成 组成事务的sql要么权执行成功，要么全执行失败 start transaction / begin //开始事务 //不能执行ddl操作（create…），因为执行ddl操作之前会默认执行一个commit命令，把这个事务结束掉 //可以执行以下操作 select… update… insert… commit / rollback //提交事务 2.事务的特性（ACID） 原子性（A
C++模拟实现String类基础功能详解
"C++中的String类是一个非常常用的数据结构，用于处理文本字符串。本文将探讨如何简单地实现一个基础版的String类，虽然不能与标准库中的std::string完全相同，但足以涵盖一些核心功能，如构造函数、拷贝构造函数、...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值