C++：使用类模拟 string 柔性数组 运算符重载 写实拷贝

最新推荐文章于 2024-07-22 10:02:43 发布
最新推荐文章于 2024-07-22 10:02:43 发布
阅读量123 收藏
点赞数
分类专栏： java 后端 文章标签： c++ c语言 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_67265311/article/details/123480545
版权

前言

如果在模拟string类时提出这种问题：若多个对象指向同一个字符串，那么会占用很多空间，如何解决？
解决方法之一就是设计一个包含柔性数组和引用计数的结构体。

目录

柔性数组结构体设计

设计一个结构体来模拟string

	struct StrNode
	{
		int ref;	 //引用计数
		int len;	 //字符串长度
		int size;	 //空间大小
		char data[]; //柔性数组
	};

类的设计

私有成员

  1. 因为要设计类，所以将柔性数组结构体(StrNode)也设计在类中，保证封装特性。

  2. 定义一个StrNode的指针作为私有成员，旨在构造对象时使用。

    class String
    {
    private:
    struct StrNode
    {
    int ref; //引用计数
    int len; //字符串长度
    int size; //空间大小
    char data[]; //柔性数组
    };

    StrNode* pstr;

    }

构造函数

	String(const char* p = NULL) : pstr(NULL)
	{
		if (p != NULL)
		{
			int len = strlen(p);
			pstr = (StrNode*)malloc(sizeof(StrNode) + len * 2 + 1);
			pstr->ref = 1;
			pstr->len = len;
			pstr->size = len * 2;
			strcpy(pstr->data, p);
		}
	}

构造对象示例：

int main(void)
{
	String s1("hello");
	return 0;
}

内存简图：
在这里插入图片描述

在这里插入图片描述

析构函数

	~String()
	{
		if (pstr != NULL && --pstr->ref == 0)
		{
			free(pstr);
		}
		pstr = NULL;
	}
  1. 首先要判断pstr是否为NULL，不为NULL时再对其引用计数 ref -= 1
  2. 若减完 ref为0，说明再没有对象指向该字符串，需要将其空间释放。
  3. 释放完成后将pstr 置为NULL。

在这里插入图片描述

拷贝构造函数

由于设计时有引用计数这个概念，所以拷贝构造时候，在判断源对象pstr不为NULL前提下，只需将

  1. pstr指针指向同一空间后

  2. 引用计数加一即可

    String(const String& s) : pstr(NULL)
{
	if (s.pstr != NULL)
	{
		pstr = s.pstr;
		pstr->ref += 1;
	}
}

示例：

int main(void)
{
	String s1("hello");
	String s2(s1);
	String s3(s2);

	return 0;
}

运行示例：

在这里插入图片描述

在这里插入图片描述

在这里插入图片描述

在这里插入图片描述

赋值运算符重载

赋值运算符流程

  1. 待赋值对象是否和源对象是同一个对象，若不是则

  2. 如果待赋值对象不为空且只有他一个对象指向堆空间，则释放该空间，若对象本身为空，不执行

  3. 将源对象赋值给待赋值对象

  4. 如果源对象不为空，那么赋值过后的待赋值对象也指向堆空间，则需要将引用计数加一

  5. 返回this指针

    // 赋值构造
String& operator =(const String& s)
{
	if (this != &s)
	{
		if (pstr != NULL && --pstr->ref == 0)
		{
			free(pstr);
		}
		pstr = s.pstr;
		if (pstr != NULL)
		{
			pstr->ref += 1;
		}
	}
	return *this;
}

示例：

int main(void)
{
	String s1("hello");
	String s2(s1);

	String s3("world");
	s3 = s2;

	return 0;
}

在没有赋值前，对象结构为：
在这里插入图片描述

赋值后，s3也指向该堆空间，将引用计数加一
在这里插入图片描述

重载[]运算符1

我们希望通过 []运算符来改变对象的字符串的某个元素，但如果是这种情况：

int main(void)
{
	String s1("hello");
	String s2(s1);

	s1[1] = 'a';
	cout << s1 << endl;

	return 0;
}

s1和s2指向同一个字符串，那么如果改变 s1，必然会改变 s2的，为了解决这种问题，需要利用写实拷贝。

写实拷贝

考虑条件：

  1. 边界条件，如果为空，程序退出。如果下标不在范围内，程序终止。

  2. 判断引用计数是否大于1，如果不大于，那么可以直接返回该下标元素，如果大于1，说明还有其他对象也指向该字符串，需要拷贝。

  3. 重新申请堆区空间，将源空间内容拷贝进去

  4. 将新空间的引用计数加一，源空间引用计数减一，最后将新空间赋给该对象的指针pstr。

    char& operator [](const int index)
{
	if (pstr == NULL) exit(1);
	assert(index >= 0 && index <= pstr->len - 1);
	if (pstr->ref > 1)
	{
		int total = sizeof(StrNode) + pstr->size + 1;
		StrNode* newNode = (StrNode*)malloc(total);
		memmove(newNode, pstr, total);
		newNode->ref = 1;
		pstr->ref -= 1;
		pstr = newNode;
	}

	return pstr->data[index];
}

示例：

在这里插入图片描述

重载[]运算符2

如果不希望这个运算符是双向的作用：即即可利用它取值，又可对其赋值，那么就不需要返回一个引用，也不用写实拷贝。

	char operator [](const int index)const
	{
		assert(index >= 0 && index <= pstr->size - 1);

		return pstr->data[index];
	}

修改某个元素 modify

当我们考虑完需求，发现既然想通过[]运算符来修改某个值，那写实拷贝也没有存在的必要，直接写一个修改函数即可。代码和写实拷贝相同。

bool modify(const int index, const char ch)	{
	assert(pstr != NULL && index >= 0 && index <= pstr->size - 1);

	if (pstr->ref > 1)	{
		int total = sizeof(StrNode) + pstr->size + 1;
		StrNode* newNode = (StrNode*)malloc(total);
		memmove(newNode, pstr, total);
		newNode->ref = 1;
		pstr->ref -= 1;
		pstr = newNode;		
	}
	pstr->data[index] = ch;
	return true;
}

移动构造与移动赋值函数

  1. 移动构造，就是将自己的资源进行转移，转移到要构造的对象里。

  2. 移动赋值，将自己的资源赋值给目标对象，自身置为NULL。

    // 移动构造
    String(String&& s) : pstr(NULL)
    {
    pstr = s.pstr;
    s.pstr = NULL;
    }

    // 移动赋值
    String& operator =(String&& s)
    {
    if (this == &s) return *this;
    if (pstr != NULL && --pstr->ref == 0)
    {
    free(pstr);
    }
    pstr = s.pstr;
    s.pstr = NULL;
    return *this;
    }

示例：

String fun()
{
	String s2("hello");
	return s2;
}
int main(void)
{
	String s1;
	s1 = fun();

	return 0;
}

在fun()函数对 s2构造时：

在这里插入图片描述

在执行到返回s2这条语句时，将移动构造一个将亡值，再将 s2本身置为NULL。
在这里插入图片描述

在返回主函数执行移动赋值，用刚才的将亡值赋值给s1，图示中的this指针就是 s1,对 s1进行了移动赋值。
在这里插入图片描述

重载（+）运算符

要完成这个函数，需要考虑这些情况：

  1. 如果两个对象都为空，则直接返回空(String())。

  2. 如果this指针不为空，被调用对象为空，则返回this指针

  3. 如果this指针为空，被调用对象不为空，返回该对象。

  4. 如果上述情况都不满足，则进行编写。

  5. 在最后返回时需要调用构造函数，为了防止调用最初所写的构造，所以重载一个特殊的构造函数。

    // operator+
String operator+(const String& s)const
{
	if (pstr == NULL && s.pstr == NULL)
	{
		return String();
	}
	else if (pstr != NULL && s.pstr == NULL)
	{
		return *this;
	}
	else if (pstr == NULL && s.pstr != NULL)
	{
		return s;
	}
	else
	{
		int total = (pstr->len + s.pstr->len) * 2;
		StrNode* newNode = (StrNode*)malloc(total + 1);
		strcpy(newNode->data, pstr->data);
		strcat(newNode->data, s.pstr->data);
		newNode->ref = 1;
		newNode->len = pstr->len + s.pstr->len;
		newNode->size = total;
		return String(newNode);
	}
}

    // 特殊的构造函数
    private:
    String(StrNode* p) : pstr§ {}

重载（+=)运算符

考虑这些情况：
当两个对象都不为空时：

  1. 如果this指针所指对象的引用计数大于1，则开辟新空间

  2. 如果引用计数等于1，那么如果size小于两个字符串长度之和，就对其扩容，否则直接拼接。

  3. 如果this指针对象为空，另一个对象不为空，则直接赋值给this指针所指对象，引用计数加一。

  4. 不满足上述条件，那么什么都不做，直接返回this

    // operator+=()
String& operator +=(const String& s)
{
	if (pstr != NULL && s.pstr != NULL)
	{
		if (pstr->ref > 1)
		{
			int total = pstr->len + s.pstr->len;
			pstr->ref -= 1;
			char* tmp = pstr->data; //
			pstr = (StrNode*)malloc(sizeof(StrNode) + total * 2 + 1);
			strcpy(pstr->data, tmp);
			strcat(pstr->data, s.pstr->data);
			pstr->ref = 1;
			pstr->len = total;
			pstr->size = total * 2;
		}
		else
		{
			int total = pstr->len + s.pstr->len;
			if (pstr->size < total)
			{
				pstr = (StrNode*)realloc(pstr, sizeof(StrNode) + total * 2 + 1);
				pstr->size = total * 2;
			}
			strcat(pstr->data, s.pstr->data);
			pstr->len = total;
		}
	}
	else if (this->pstr == NULL && s.pstr != NULL)
	{
		pstr = s.pstr;
		pstr->ref += 1;
	}
	return *this;
}

示例：

int main(void)
{
	String s1("Hello");
	String s2("world");

	s1 += s2;
	return 0;
}

第一种情况，两个数据相加没超过源对象的size ，直接拼接即可
在这里插入图片描述

第二种情况，加等时数据超过size：

int main(void)
{
	String s1("Hello");
	String s2("world2022_3_12");

	s1 += s2;
	return 0;
}

执行完毕后， s1的size扩容到 38了。
在这里插入图片描述

end源代码

class String
{
private:
	struct StrNode
	{
		int ref;	 //引用计数
		int len;	 //字符串长度
		int size;	 //空间大小
		char data[]; //柔性数组
	};
	StrNode* pstr;
	String(StrNode* p) : pstr(p) {}
public:
	String(const char* p = NULL) : pstr(NULL)
	{
		if (p != NULL)
		{
			int len = strlen(p);
			pstr = (StrNode*)malloc(sizeof(StrNode) + len * 2 + 1);
			pstr->ref = 1;
			pstr->len = len;
			pstr->size = len * 2;
			strcpy(pstr->data, p);
		}
	}
	~String()
	{
		if (pstr != NULL && --pstr->ref == 0)
		{
			free(pstr);
		}
		pstr = NULL;
	}

	// 拷贝构造
	String(const String& s) : pstr(NULL)
	{
		if (s.pstr != NULL)
		{
			pstr = s.pstr;
			pstr->ref += 1;
		}
	}
	
	// 赋值构造
	String& operator =(const String& s)
	{
		if (this != &s)
		{
			if (pstr != NULL && --pstr->ref == 0)
			{
				free(pstr);
			}
			pstr = s.pstr;
			if (pstr != NULL)
			{
				pstr->ref += 1;
			}
		}
		return *this;
	}

	//写实拷贝
	char& operator [](const int index)
	{
		if (pstr == NULL) exit(1);
		assert(index >= 0 && index <= pstr->len - 1);
		if (pstr->ref > 1)
		{
			int total = sizeof(StrNode) + pstr->size + 1;
			StrNode* newNode = (StrNode*)malloc(total);
			memmove(newNode, pstr, total);
			newNode->ref = 1;
			pstr->ref -= 1;
			pstr = newNode;
		}

		return pstr->data[index];
	}

	char operator [](const int index)const
	{
		assert(pstr != NULL && index >= 0 && index <= pstr->size - 1);

		return pstr->data[index];
	}

	// 修改
	bool modify(const int index, const char ch)
	{
		assert(pstr != NULL && index >= 0 && index <= pstr->size - 1);

		if (pstr->ref > 1)
		{
			int total = sizeof(StrNode) + pstr->size + 1;
			StrNode* newNode = (StrNode*)malloc(total);
			memmove(newNode, pstr, total);
			newNode->ref = 1;
			pstr->ref -= 1;
			pstr = newNode;
		}
		pstr->data[index] = ch;
		return true;
	}

	// 移动构造
	String(String&& s) : pstr(NULL)
	{
		pstr = s.pstr;
		s.pstr = NULL;
	}
	// 移动赋值
	String& operator =(String&& s)
	{
		if (this == &s) return *this;
		if (pstr != NULL && --pstr->ref == 0)
		{
			free(pstr);
		}
		pstr = s.pstr;
		s.pstr = NULL;
		return *this;
	}

	// operator+
	String operator+(const String& s)const
	{
		if (pstr == NULL && s.pstr == NULL)
		{
			return String();
		}
		else if (pstr != NULL && s.pstr == NULL)
		{
			return *this;
		}
		else if (pstr == NULL && s.pstr != NULL)
		{
			return s;
		}
		else
		{
			int total = (pstr->len + s.pstr->len) * 2;
			StrNode* newNode = (StrNode*)malloc(total + 1);
			strcpy(newNode->data, pstr->data);
			strcat(newNode->data, s.pstr->data);
			newNode->ref = 1;
			newNode->len = pstr->len + s.pstr->len;
			newNode->size = total;
			return String(newNode);
		}
	}

	// operator+=()
	String& operator +=(const String& s)
	{
		if (pstr != NULL && s.pstr != NULL)
		{
			if (pstr->ref > 1)
			{
				int total = pstr->len + s.pstr->len;
				pstr->ref -= 1;
				char* tmp = pstr->data; //
				pstr = (StrNode*)malloc(sizeof(StrNode) + total * 2 + 1);
				strcpy(pstr->data, tmp);
				strcat(pstr->data, s.pstr->data);
				pstr->ref = 1;
				pstr->len = total;
				pstr->size = total * 2;
			}
			else
			{
				int total = pstr->len + s.pstr->len;
				if (pstr->size < total)
				{
					pstr = (StrNode*)realloc(pstr, sizeof(StrNode) + total * 2 + 1);
					pstr->size = total * 2;
				}
				strcat(pstr->data, s.pstr->data);
				pstr->len = total;
			}
		}
		else if (this->pstr == NULL && s.pstr != NULL)
		{
			pstr = s.pstr;
			pstr->ref += 1;
		}
		return *this;
	}
	// 输出运算符
	ostream& operator <<(ostream& out) const
	{
		if (pstr != NULL)
		{
			out << pstr->data;
		}
		return out;
	}

};
ostream& operator<<(ostream& out, const String& s)
{
	s << out;
	return out;
}
m0_67265311
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C++课程作业：类定义、运算符重载、类模板
06-09
C++课程作业：类定义、运算符重载、类模板
C++：使用类模拟 string | 柔性数组 | 运算符重载 | 写实拷贝
Sauron7i的博客
03-12 1147
柔性数组 设计一个结构体来模拟string 写实拷贝 重载+=运算符 重载+运算符 重载[]运算符
C++运算符重载二：模拟实现string类
Rain的博客
03-11 487
模拟实现string类： 我们使用C语言的string时，有一些不方便的地方： 1.定义数组的时候大小必须固定。 2.字符串进行比较大小，连接的时候必须调用相应的字符串操作函数。 3.还必须考虑内存是否够用，操作起来比较麻烦。 而我们C++提供了string类型，操作起来比较简单，这些操作都可以通过string来使用： string str1;//默认构造 string str2 = "aaa";...
C++运算符重载、自己实现的String类
weixin_45312249的博客
05-13 518
运算符重载 重载本质上是函数调用，并且一个运算符在同一个类中只能被重载一次 = （） -> [] 只能采用成员函数的方式重载 . .* ?: ::这些不能被重载 习惯： 单目运算符采用类成员函数方式重载，双目运算符采用友元函数方式实现 有如下分类： 流重载： 只能采用友元函数方式重载 流重载函数返回值必须是引用 输入流重载： 例子： string name; cin>>name; 分支cin istream类的对象 输出流重载：例子： string name; co
C++STL详解(二)：string的模拟实现
weixin_51885188的博客
01-30 586
文章目录string的深浅拷贝问题浅拷贝深拷贝传统写法string类各函数的接口默认成员函数构造函数拷贝构造函数赋值运算符重载析构函数与迭代器相关的函数beginend与容量和大小相关的函数sizecapacityemptyreserveresize修改字符串的函数push_backappendoperator+=swapinserteraseclearc_str字符串访问与查找函数findoperator[]关系运算符重载函数<运算符重载==运算符重载<=运算符重载>运算符重载>=
C++string的模拟实现
qq_52145272的博客
03-04 594
C++string的模拟实现
C++实践分数类中运算符重载的方法参考
01-21
【项目-分数类中的运算符重载】 （1）实现分数类中的运算符重载，在分数类中可以完成分数的加减乘除（运算后再化简）、比较（6种关系）的运算。 class CFraction { private: int nume; // 分子 int deno; // ...
C++实践Time类中的运算符重载参考方法
08-26
C++实践Time类中的运算符重载参考方法 在C++programming语言中，运算符重载是指可以根据不同的需求，重新定义C++语言中的运算符，以适应不同的数据类型和需求。在本篇文章中，我们将分享C++实践Time类中的运算符...
详解C++中String类模拟实现以及深拷贝浅拷贝
12-31
字符串是一个应用很广泛的类型，也是很基础的类型，C语言并没有直接处理字符串的操作而是采用字符指针和字符串数组进行操作，而在C++中标准库为我们封装了一个字符串的类供我们使用，使用需要#inlcude <string>...
Polyop:C++14 的可覆盖通用运算符重载
07-14
C++ 支持运算符重载，当它们与用户定义的类型一起使用时，允许用户为该运算符指定自定义语义。 例如： struct foo {}; std::ostream& operator <<( std::ostream& os , const foo& ){ return os << " a...
string类的模拟实现--运算符重载
qq_53413129的博客
03-11 592
"<"运算符重载 "=="运算符重载 其他运算符重载 流运算符重载
C++二叉搜索树
Jk_Mr的博客
07-20 1095
树结构是一种重要的数据结构。树是一种非线性的数据结构，它是由n（n>=0）个有限结点组成一个具有层次关系的集合。把它叫做树是因为它看起来像一棵倒挂的树，也就是说它是根朝上，而叶朝下的。
C++ 继承篇
2301_79201049的博客
07-18 700
必须对继承而来的成员进行初始化直接通过初始化列表或者赋值的方式进行初始化调用父类构造函数进行初始化
【C++】操作符“new”和“delete”（创建和销毁对象）
qq_65596720的博客
07-19 392
由于C++引入了类的概念所以创建空间和销毁空间变得复杂，使用malloc和free会更加复杂，所以C++引入了new和delete来简化代码。
商品信息管理系统(C语言)
zeyeqianli的博客
07-22 237
该案例使用了C语言中最具特色的结构体，将每个商品的所有信息存在结构体中，并且定义一个结构体类型的数组保存所有商品的信息，并且按照模块化的编程思想，将要实现的每个功能编写成独立的函数，这样即方便阅读同时也方便差错修改。该系统的主要功能如下：(1) 登录系统。(2) 创建商品信息。(3) 打印商品信息。(4) 查询商品信息。(5) 修改商品信息。(6) 删除商品信息。(7) 商品价格排名显示。(8) 退出系统。
C++笔记3：基类指针delete子类对象的内存泄漏问题
subtitle_的博客
07-21 231
C++笔记3：基类指针delete子类对象的内存泄漏问题
2024年华为OD机试真题-虚拟游戏理财-C++-OD统一考试（C卷D卷）
面试高手的博客
07-21 9727
现有一家Bank，它提供有若干理财产品m，风险及投资回报不同，你有N（元）进行投资，能接受的总风险值为X。第一行：产品数(取值范围[1, 20])，总投资额(整数，取值范围[1, 10000])，可接受的总风险(整数，取值范围[1, 200])投资第二项30个单位，第四项40个单位，总的投资风险为两项相加为4+6=10。第四行：最大投资额度序列，输入为整数，取值范围[1,10000]第二行：产品投资回报率序列，输入为整数，取值范围[1,60]第三行：产品风险值序列，输入为整数，取值范围[1,100]
C语言 打印菱形的程序（Program to print the Diamond Shape）
最新发布
csdn_aspnet的专栏
07-22 1437
O(n*n)，因为我们正在遍历网格的行和列来打印空格 ' '和星号 '*'。给定一个数字n ，编写一个程序来打印一个有2n行的菱形。O(1)，不使用额外空间。
【C++修炼之路 第三章：内存管理】new & delete、operator new & operator delete
唯有忍受别人不能忍受的，才能享受别人不能享受的
07-18 723
【含常见面试题】new & delete 的概念与用法 + 定位new表达式 + malloc/free 和 new/delete 的区别
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值