（深拷贝&&浅拷贝）&&（引用计数&&写时拷贝）

最新推荐文章于 2024-09-15 11:40:06 发布
最新推荐文章于 2024-09-15 11:40:06 发布
阅读量99 收藏
点赞数
文章标签： c++ jvm 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_52343363/article/details/130141547
版权
文章详细介绍了C++中的深拷贝和浅拷贝的概念，通过示例代码展示了它们的区别。浅拷贝会导致对象共享同一内存空间，可能引发doublefree问题，而深拷贝会创建新的内存空间以避免此类问题。此外，文章还提到了引用计数作为解决浅拷贝问题的一种策略，通过跟踪对象的引用次数，在最后一个对象析构时释放资源，确保内存安全。
摘要由CSDN通过智能技术生成

深拷贝与浅拷贝的区别

浅拷贝（默认拷贝函数）：将原对象或原数组的引用直接赋给新对象，新数组，新对象/新数组只是原对象的一个引用。

深拷贝：创建一个新的对象和数组，将原对象的各项属性的“值”（数组的所有元素）拷贝过来，是“值”而不是引用

深拷贝会在堆内存中另外申请空间来储存数据，从而解决了指针悬挂问题。当数据成员中有指针时，必须要用深拷贝

浅拷贝

打断点  F11 进行调试

#include <iostream>
#include <string>

using namespace std;

class String
{
public:
	String(const char *str="")
	{
		m_data = new char[strlen((str)+1)];
		strcpy(m_data, str);
	}
	~String()
	{
		delete[]m_data;
		m_data = nullptr;
	}
private:
	char* m_data;
};

void main()
{
	String s1("abc");
	String s2 = s1;

	cout << "end";
}

 

 

 可以看到s1->m_data与s2->m_data地址相同，他们的指针指向了同一地址空间，也就是说s2->m_data并没有自己的地址空间，s2->m_data指向了 s1->m_data地址空间，当 s1对象进行销毁时，会调用析构函数对s1在堆上的空间进行销毁，等到要销毁s2对象时其在堆上空间已经被释放,调用析构函数 会产生double free的错误；

 

深拷贝

深拷贝方法就是对以前的地址空间内容再进行拷贝一份申请了新的空间，使得拷贝的对象指向新的地址空间，这样就可以避免一个空间同时被析构两次的问题。 

#include <iostream>
#include <string>

using namespace std;

class String
{
public:
	String( const char *str="")
	{
		m_data = new char[strlen((str)+1)];
		strcpy(m_data, str);
	}

	String(const String &s)
	{
		this->m_data = new char[strlen(s.m_data)+1];
		strcpy(this->m_data, s.m_data);
	}

	String &operator=(const String &s)
	{
		if (this != &s)
		{
			this->m_data = new char[strlen(s.m_data) + 1];
			strcpy(this->m_data, s.m_data);
		}	
		return *this;
	}

	~String()
	{
		delete []m_data;
		m_data = nullptr;
	}

private:
	char* m_data;
};

void main()
{
	String s1("abc");
	String s2;
	s2 = s1;
	
	cout << "end";
}

深浅/拷贝---好坏之分

深浅拷贝，并没有好坏之分，任何事物都要以辩证的视角来看,

以操作系统 读者写者角度来看，假设m_data是我们的资源和文件，以读者的身份其实我们不需要修改它，我们只要能进行阅读就可以了，这样我们只需要一个资源空间，便可以满足多个对象的访问。

在写者角度来看，则必须支持深拷贝，因为不深拷贝不但double free 而且会让别的对象的资源文件发生改变。

为此浅拷贝的引用计数也 由此而生


浅拷贝引用计数

操作系统 读写者问题  便可以采用引用计数，

创建一个文件只开放读权限，该资源允许所有对象去读，直到最后一个读者离开时，才释放资源。

 

采用引用计数 

地址相同,且程序能够正常执行

 

#include<iostream>
#include<list>
#include<vector>
#include<string>

using namespace std;

class String;

//引用计数类
class String_rep
{
	friend class String;
	friend ostream& operator<<(ostream& out, const String& s);
public:
	String_rep(const char* str = "") :m_count(0)
	{
		m_data = new char[strlen(str) + 1];
		strcpy(m_data, str);
	}
	String_rep(const String_rep& rep) :m_data(nullptr), m_count(0)
	{
		String_rep _Tmp(rep.m_data);
		swap(m_data, _Tmp.m_data);
	}
	String_rep& operator=(const String_rep& rep)
	{
		if (this != &rep)
		{
			String_rep _Tmp(rep);
			swap(m_data, _Tmp.m_data);
		}
		return *this;
	}
	~String_rep()
	{
		delete[]m_data;
		m_data = nullptr;
	}
public:
	void Increment()
	{
		m_count++;
	}
	void Decrement()
	{
		if (--m_count == 0)
		{
			delete this;
		}
	}
private:
	char* m_data;
	int   m_count; //引用计数
};

class String
{
	friend ostream& operator<<(ostream& out, const String& s);
public:
	String(const char* str = "") :rep(new String_rep(str))
	{
		rep->Increment();
	}
	String(const String& s) :rep(s.rep)
	{
		rep->Increment();
	}
	String& operator=(const String& s)
	{
		if (this != &s)
		{
			rep->Decrement();
			rep = s.rep;
			rep->Increment();
		}
		return *this;
	}
	~String()
	{
		rep->Decrement();
	}
public:
	void to_upper()
	{
		//写时拷贝
		String_rep* new_rep = new String_rep(rep->m_data);
		rep->Decrement();
		rep = new_rep;
		rep->Increment();

		char* pch = rep->m_data;
		while (*pch != '\0')
		{
			if (*pch >= 'a' && *pch <= 'z')
				*pch -= 32;
			pch++;
		}
	}
private:
	String_rep* rep;
};

ostream& operator<<(ostream& out, const String& s)
{
	out << s.rep->m_data;
	return out;
}

void main()
{
	String s1("abc");
	String s2 = s1;

	cout << "s1 = " << s1 << endl;
	cout << "s2 = " << s2 << endl;

	s1.to_upper();

	cout << "s1 = " << s1 << endl;
	cout << "s2 = " << s2 << endl;
}

 

 这里this是谁？

自杀，防止了内存泄漏，其他对象析构的时候就会调用析构函数减少计数器数量，当最后一个对象析构的时候先调用自身析构方法，然后也紧接着要减少计数器，当等于0的时候，就delete this

  

 会调用析构函数将自己所指的空间释放掉,然后在将this对象销毁,避免内存泄漏.

​
#include<iostream>
#include<list>
#include<vector>
#include<string>

using namespace std;

class String;

//引用计数类
class String_rep
{
	friend class String;
	friend ostream& operator<<(ostream& out, const String& s);
public:
	String_rep(const char* str = "") :m_count(0)
	{
		m_data = new char[strlen(str) + 1];
		strcpy(m_data, str);
	}
	String_rep(const String_rep& rep) :m_data(nullptr), m_count(0)
	{
		String_rep _Tmp(rep.m_data);
		swap(m_data, _Tmp.m_data);
	}
	String_rep& operator=(const String_rep& rep)
	{
		if (this != &rep)
		{
			String_rep _Tmp(rep);
			swap(m_data, _Tmp.m_data);
		}
		return *this;
	}
	~String_rep()
	{
		delete[]m_data;
		m_data = nullptr;
	}
public:
	void Increment()
	{
		m_count++;
	}
	void Decrement()
	{
		if (--m_count == 0)
		{
			delete this;//自己干掉自己
		}
	}
private:
	char* m_data;
	int   m_count; //引用计数
};

class String
{
	friend ostream& operator<<(ostream& out, const String& s);
public:
	String(const char* str = "") :rep(new String_rep(str))
	{
		rep->Increment();
	}
	String(const String& s) :rep(s.rep)
	{
		rep->Increment();
	}
	String& operator=(const String& s)
	{
		if (this != &s)
		{
			rep->Decrement();
			rep = s.rep;
			rep->Increment();
		}
		return *this;
	}
	~String()
	{
		rep->Decrement();
	}
public:
	void to_upper()
	{
		//写时拷贝
		String_rep* new_rep = new String_rep(rep->m_data);//将资源拷贝过来
		rep->Decrement();//由于要对资源变更,从旧的资源将指针移开,引用计数器--
		rep = new_rep;//要变更的指针指向了拷贝的资源
		rep->Increment();//拷贝的资源引用计数器++

		char* pch = rep->m_data;//变更操作为转化为大写
		while (*pch != '\0')
		{
			if (*pch >= 'a' && *pch <= 'z')
				*pch -= 32;
			pch++;
		}
	}
private:
	String_rep* rep;
};

ostream& operator<<(ostream& out, const String& s)
{
	out << s.rep->m_data;
	return out;
}

void main()
{
	String s1("abc");
	String s2 = s1;

	cout << "s1 = " << s1 << endl;
	cout << "s2 = " << s2 << endl;

	s1.to_upper();

	cout << "s1 = " << s1 << endl;
	cout << "s2 = " << s2 << endl;
}

​

赋值操作的写法

s2对象给s1 赋值，s1所指向的空间计数器要减一,(s1指向了s2空间) s2空间计数器要++;

	String& operator=(const String &s)
	{
		if(this != &s)
		{
			rep->Decrement();
			rep = s.rep;
			rep->Increment();
		}
		return *this;
	}

 写时拷贝

之前的对象共用一个资源，但是现在有对象期望对资源进行修改，我们应当具备这样的功能

在想进行修改时，将 源资源(最开始的资源)  拷贝一份给想修改资源的对象

	void to_upper()
	{
		//写时拷贝
		String_rep* new_rep = new String_rep(rep->m_data);//将资源拷贝过来
		rep->Decrement();//由于要对资源变更,从旧的资源将指针移开,引用计数器--
		rep = new_rep;//要变更的指针指向了拷贝的资源
		rep->Increment();//拷贝的资源引用计数器++

		char* pch = rep->m_data;//变更操作为转化为大写
		while (*pch != '\0')
		{
			if (*pch >= 'a' && *pch <= 'z')
				*pch -= 32;
			pch++;
		}
	}

曹叡不是睿
关注
C++浅拷贝与深拷贝及引用计数分析
08-30
C++浅拷贝与深拷贝及引用计数分析 C++浅拷贝与深拷贝及引用计数分析是C++开发中经常遇到的问题之一，浅拷贝会导致double free、内存泄露等严重的问题。在C++类中，如果成员变量包括指针，而又没有定义自己的拷贝...
通过源码分析iOS中的深拷贝与浅拷贝
01-20
在iOS开发中，深拷贝和浅拷贝是两个关键概念，主要涉及到对象复制时内存管理的策略。本文将从源码层面深入解析这两种拷贝方式的差异。 首先，浅拷贝（指针拷贝）是指复制对象时，只复制对象的指针，即创建一个新的...
//浅拷贝&&//深拷贝
m0_72566333的博客
07-22 112
黑马程序员C++笔记
【C++初阶】引用计数和写时拷贝是什么？用来干嘛的？
Weraphael的博客
08-17 187
了解引用计数和写时拷贝
浅拷贝&深拷贝&引用计数
qq_40995354的博客
07-27 489
当类里面有对象时，进行简单的赋值的浅拷贝，当s1和s2中包含的指针对象同时指向一块内存，析构时delete了两次这个内存，会出错， 存在崩溃的问题。这里我们需要深拷贝。 构造s2时拷贝一块跟s1指向数据块一样大的数据块，并将值拷贝下来，这样s1和s2指向各自的数据块，析构时释放各自的数据块。 浅拷贝存在析构多次的问题，深拷贝又会浪费空间，有没有更好一点的方法呢？ 为了解决浅拷贝中同一...
STL之浅拷贝&深拷贝&写实拷贝
flyingcloud6的博客
10-27 811
浅拷贝和深拷贝各有利弊，要辩证的看待，同时要学习写实拷贝
深拷贝&浅拷贝&引用计数&写时拷贝
weixin_34186931的博客
03-24 59
(1).浅拷贝： class String { public: String(const char* str="") :_str(new char[strlen(str)+1]) { strcpy(_str,str); } ~String() { if(NULL!...
浅析深拷贝之写时拷贝&引用计数
SUST_YuXiao
11-07 426
形如百度网盘上传用户文件到服务器时，对于同一文件（如某软件安装包）服务器若将多个用户的同一文件独立存储，那么将浪费极大的存储空间。 正确的做法是: 在文件内容发生更改时进行深拷贝，在文件未发生变化时进行浅拷贝。 在文件内容剩最后一份需要析构时释放空间，否则不释放空间
C++的String类的实现 && 深拷贝 && 写时拷贝
Yinghuhu333333的博客
04-19 547
浅拷贝的缺陷？ ①普通的浅拷贝会在拷贝构造初始化完成后，对象在生命周期结束后，就会析构多次而使程序崩溃。 ②如果改变了其中的一个值，另外一个也会随之而改变。 所以为了防止以上两种问题，就有了解决的方案。 1. 深拷贝 在拷贝的时候，为其也申请相同大小的一块空间。每个对象都指向自己的空间。这样就不会因为析构同一块空间而出现崩溃。 但是，在有些情况下深拷贝会浪费空间。比如：当现实中...
深拷贝&浅拷贝&写时拷贝
aaronlanni的博客
10-15 394
学习深拷贝与浅拷贝，有助于我们以后的整体学习，因此希望这些内容，可以给大家带去帮助！
C++String浅拷贝&深拷贝&Copy On Write
Mr_Garfield__的博客
05-05 901
简单的赋值拷贝 class String { public: String(constchar*str) :_str(newchar [strlen(str)+1]) { strcpy(_str,str); } String(constString&amp;str) :_str(str._str) {...
浅析iOS中的浅拷贝和深拷贝(copy和mutableCopy)
01-20
在iOS开发中，了解浅拷贝和深拷贝的概念至关重要，因为它们直接影响到对象的生命周期和内存管理。本文将深入浅析iOS中的`...在处理集合对象时尤其需要注意，因为它们的拷贝行为可能涉及到内部对象的浅拷贝或深拷贝。
C++ STL中sort函数
最新发布
weixin_43349440的博客
09-15 166
刷题中经常遇到，用于各种元素排序，可以自定义排序方式，vector、deque适用。详细讲解：https://zhuanlan.zhihu.com/p/36274119。，为避免QuickSort快排的递归调用带来过大的额外负荷，就改用。一旦分段后的数据量小于某个门槛。STL的sort算法，
C++与QML的数据交互
qq_50679120的博客
09-11 513
这里没什么好说的，在C++中组合好json后，通过信号发送到qml中，qml中是可以解析json的。通过Q_PROPERTY属性，可以轻松地在QML中读取和修改数据，并将其更新到C++中，先创建一个类。在QML接收，直接通过data.can_id这样的形式去访问结构体中的元素。这两个也没什么好说的，在C++中直接发送信号就好了，在C++中声明并注册一个结构体。然后发送信号到QML中。
CF C. Nikita and LCM
qq_74190237的博客
09-13 258
思维题.首先先对数组排序,考虑一种特殊情况,那就是如果数组最大值不能被其他数整除,这代表什么?代表其他数里面有某个质因子,最大值里面没有或者数量不管,所有最小公倍数都会大于最大值.那么其他情况的话,就可以确定所有的数都是最大数的因子,那么形成的最小公倍数也一定是最大数的因子,那么就可以枚举一下最大数的因子,就可以了.给长度为n的数组,求出最长的特殊子数组,如果子数组的最小公倍数不在原数组中,那么就是特殊的.
C和指针：标准函数库
暮色年华的博客
09-11 675
longjmp 函数:一旦在程序的其他部分遇到了 longjmp 调用，并且传入了之前 setjmp 初始化的 jmp_buf 数组以及一个非零值作为跳转值，那么程序的控制就会立即跳回到与那个 jmp_buf 关联的 setjmp 处。setjmp 函数：一个函数中调用 setjmp 并传递一个类型为 jmp_buf 的数组作为参数时，setjmp 将会保存当前程序执行环境的一个快照（包括处理器寄存器和程序计数器等状态信息）到这个 jmp_buf 数组中。如果在某个低层的函数中检测到一个错误，你可以立。
C语言从头学59——学习头文件math.h（二）
m0_72128260的博客
09-11 470
继续学习头文件的数学函数。
＜C++＞ set、map模拟实现
prodigy623的博客
09-10 904
set、map仿STL模拟实现
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值