C++新特性15_引用计数(引用计数是为了解决使用浅拷贝可能造成的资源重复释放问题，通过引入引用计数：增加一个变量，记录资源使用的次数，控制资源的释放)

已于 2024-02-04 11:34:19 修改
阅读量1.3k 收藏 8
点赞数 3
分类专栏： # C++新特性37篇 文章标签： c++
于 2021-11-18 11:35:54 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Dasis/article/details/121395528
版权

要正确的理解智能指针，首先必须理解引用计数的技术。

C++新特性15_引用计数

1. 深拷贝、浅拷贝的概念

前面介绍深拷贝与浅拷贝，请参考：C++57个入门知识点_24_ 浅拷贝与深拷贝（浅拷贝：对象1、2均指向一块内存； 深拷贝：重新分配内存，将对象1内容复制给对象2；何时重写拷贝构造函数：对象成员非基本数据类型，为资源时需重写或禁用）
深拷贝：当对象里面的资源，进行复制时需要写拷贝构造函数，拷贝构造函数需要对内容重新进行拷贝
浅拷贝：只是值传递

1.1 深拷贝优缺点：

  • 优点：每一个的对象（哪怕是通过拷贝构造函数实例化的对象）的指针都有指向的内存空间，而不是共享，所以在对象析构的时候就不存在重复释放或内存泄露的问题了。
  • 缺点：内存开销大

1.2 浅拷贝优缺点：

  • 优点：通过拷贝构造函数实例化的对象的指针数据变量指向的共享的内存空间，因此内存开销较小。
  • 缺点：对象析构的时候就可能会重复释放或造成内存泄露。

​ 鉴于深拷贝和浅拷贝的优缺点，可采用引用计数技术，既减小了内存开销，又避免了堆的重复释放或内存泄露问题。

1.3 举例说明

  • 在深拷贝的情况下，通过拷贝构造或者赋值构造的对象均各自包含自己的指针指向“Hello”。
    在这里插入图片描述
  • 浅拷贝
    在这里插入图片描述

2. 举例查看浅拷贝的问题

以下通过实例查看浅拷贝会存在的问题


#include <iostream>
#include <vector>
#include <algorithm>
#include <functional>
using namespace std;

class CStudent
{
public:
	CStudent(const char* pszName);//构造
	CStudent(CStudent& obj);//拷贝构造

	CStudent& operator=(CStudent& obj);//=的运算符重载

	void release();

	void Show()
	{
		//打印出地址及内容
		cout << hex << (int&)m_pszName << m_pszName << endl;
	}

private:
	char* m_pszName;
};


CStudent::CStudent(const char* pszName)
{
	m_pszName = new char[256];//分配堆空间

	strcpy(m_pszName, pszName);
}


CStudent::CStudent(CStudent& obj)
{
	//浅拷贝
	m_pszName = obj.m_pszName;

	//strcpy(m_pszName, obj.m_pszName);
}

//main中采用stu1 = stu2;这种形式时才会调用=运算符重载，这里使用是为防止此种形式的拷贝
CStudent& CStudent::operator=(CStudent& obj)
{
	//浅拷贝
	m_pszName = obj.m_pszName;

	return *this;
}

void CStudent::release()
{
	if (m_pszName != NULL)
	{
		delete m_pszName;
		m_pszName = NULL;
	}
}

int main(int argc, char* argv[])
{
	CStudent stu1("zhang san");

	CStudent stu2("li si");

     //跳转至CStudent::CStudent(CStudent& obj)
     //此种写法参考C++57个入门知识点_20_ 构造函数的调用中构造函数只有一个参数的隐式转换表达的方式
     //CStudent stu3是一个没有构造的对象，首先需要调用构造函数，通过上面隐式转换的形式，调用只有一个参数为CStudent&的构造函数
	CStudent stu3 = stu2; 

	stu1.Show();
	stu2.Show();
	stu3.Show();

	stu2.release();

	stu3.Show();

	return 0;
}

设置断点查看之后可以看到stu2,stu3浅拷贝，指向同一个内存，在释放时可能会存在重复释放的问题。
在这里插入图片描述
浅拷贝的析构
在这里插入图片描述
但是这样同样存在问题，一旦其中一个对象释放了资源，那么所有的其他对象的资源也被释放了。

补充：
上面=运算符重载被调用代码如下：

	CStudent stu3("li si");
	stu3 = stu2;

因为stu3已经被构造，已经是一个对象，stu3 = stu2时不会再调用构造函数，而是调用=的重载类型

3. 浅拷贝重复释放资源解决方法：增加一个变量，记录资源使用的次数

打个比方：教室里5名同学，空调为5名同学共用，用一个计数器，当1个同学走了就计数1，当所有同学走了之后才关闭空调。
在这里插入图片描述


#include <iostream>
#include <vector>
#include <algorithm>
#include <functional>
using namespace std;

class CStudent
{
public:
	CStudent(const char* pszName);
	CStudent(CStudent& obj);

	~CStudent();

	CStudent& operator=(CStudent& obj);

	void release();

	void Show()
	{
		if (*m_pCount > 0)
		{
			cout << hex << (int&)m_pszName << m_pszName << endl;
		}
	}

private:
	char* m_pszName;

	//资源计数器，当资源计数器减为0时，表示该资源可以被释放，从而避免重复被释放的问题
	int * m_pCount; //资源与计数器绑定，必须用指针写
};


CStudent::CStudent(const char* pszName)
{
	m_pszName = new char[256];
	m_pCount = new int;

	strcpy(m_pszName, pszName);

	*m_pCount = 1;
}


CStudent::CStudent(CStudent& obj)
{
	//首先浅拷贝
	m_pszName = obj.m_pszName;
	
	//让使用该资源的人均使用同一个计数器
	m_pCount = obj.m_pCount;
	(*m_pCount)++;

}

CStudent::~CStudent()
{
	release();
}

//main中采用stu1 = stu2;这种形式时才会调用=运算符重载，这里使用是为防止此种形式的拷贝
CStudent& CStudent::operator=(CStudent& obj)
{
	//=的拷贝操作
	if (obj.m_pszName == m_pszName)
	{
		return *this;
	}

	if (--(*m_pCount) == 0)
	{
		delete m_pszName;
		m_pszName = NULL;
		delete m_pCount;

	}

	m_pszName = obj.m_pszName;
	m_pCount = obj.m_pCount;

	(*m_pCount)++;

	return *this;
}

void CStudent::release()
{
	if (m_pszName != NULL && --*m_pCount == 0)
	{
		//通过计数器避免资源的重复释放的问题
		delete m_pszName;
		m_pszName = NULL;

		delete m_pCount;
	}
}

int main(int argc, char* argv[])
{
	CStudent stu1("zhang san");

	CStudent stu2("li si");

     //跳转至CStudent::CStudent(CStudent& obj)，拷贝构造，参考C++57个入门知识点_23_ 拷贝构造函数（利用一个对象创建另一个对象，调用的构造函数即拷贝构造函数)
	CStudent stu3 = stu2; 


	stu1.Show();
	stu2.Show();
	stu3.Show();

	stu2.release();
	stu3.release();

	stu3.Show();

	return 0;
}

运行结果：
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

4. 引用计数的类封装

最后，我们将该引用计数做一个简易的封装，也就是把引用计数作为一个新的类来使用：


#include <iostream>
#include <vector>
#include <algorithm>
#include <functional>
using namespace std;

struct RefValue
{

	RefValue(const char* pszName);
	~RefValue();

	void AddRef();
	void Release();

	char* m_pszName;
	int   m_nCount;
};

RefValue::RefValue(const char* pszName)
{
	m_pszName = new char[strlen(pszName) + 1];

	m_nCount = 1;

}

RefValue::~RefValue()
{

	if (m_pszName != NULL)
	{
		delete m_pszName;
		m_pszName = NULL;
	}
}

void RefValue::AddRef()
{
	m_nCount++;
}

void RefValue::Release()
{
	if (--m_nCount == 0)
	{
		delete this;
	}

}


class CStudent
{
public:
	CStudent(const char* pszName);
	CStudent(CStudent& obj);

	~CStudent();

	CStudent& operator=(CStudent& obj);

	void release();

	void Show()
	{
		if (m_pValue->m_nCount > 0)
		{
			cout << hex << (int&)m_pValue->m_pszName << m_pValue->m_nCount << endl;
		}
	}

private:
	RefValue* m_pValue;
};


CStudent::CStudent(const char* pszName)
{
	m_pValue = new RefValue(pszName);
}


CStudent::CStudent(CStudent& obj)
{
	m_pValue = obj.m_pValue;
	m_pValue->AddRef();
}

CStudent::~CStudent()
{
	release();
}


CStudent& CStudent::operator=(CStudent& obj)
{
	if (obj.m_pValue == m_pValue)
	{
		return *this;
	}

	m_pValue->Release();

	m_pValue = obj.m_pValue;
	m_pValue->AddRef();

	return *this;
}

void CStudent::release()
{
	m_pValue->Release();
}

int main(int argc, char* argv[])
{
	CStudent stu1("zhang san");

	CStudent stu2("li si");
	//拷贝构造
	CStudent stu3 = stu2;


	stu1.Show();
	stu2.Show();
	stu3.Show();

	stu2.release();
	//stu3.release();

	stu3.Show();

	stu3.release();

	return 0;
}

5. 引用计数存在的问题

  • 上面的做法能在一定程度上解决资源多次重复申请的浪费，但是仍然存在两个核心的问题。
  • 如果对其中某一个类对象中的资源进行了修改，那么所有引用该资源的对象全部会被修改，这显然是错误的。
  • 当前的计数器作用于Student类，在使用时候，需要强行加上引用计数类，这样复用性不好，使用不方便。
    后面需要对上面两个问题进行修正

6.学习视频地址：引用计数
7.学习笔记：引用计数笔记

十月旧城
关注
专栏目录
C++ 引用计数器
阿艾辣悟叩德
12-14 4427
今天讲一个实用的东西，C++类的引用计数，不废话直接上代码；#ifdef WIN32 #include <Windows.h> #else #include <atomic> #endif using namespace std; class CCRefCounter { public: CCRefCounter(); ~CCRefCounter(){}; //增加引用计数;
C++智能指针 shared_ptr引用计数分析
DU_YULIN的博客
09-10 3660
文章目录前言一、C++ 智能指针shared_ptr总结 前言 今天和人争论C++ 智能指针shared_ptr引用计数问题，然后代码实现验证，这里分享给大家。 一、C++ 智能指针shared_ptr shared_ptr智能指针是一个类，用于管理new 分配的对象，该智能指针类内部有一个保存引用计数的属性，通过这个属性来判断是否可以释放要管理的对象, 该判断是在智能指针类shared_ptr的析构函数中进行。当引用计数为0时，表示当前程序没有用到该管理对象的地方了，可以释放该管理对象了，即delet
c/c++ 引用计数
10-11 254
　　记录一下，希望以后会用到。 　　假若我们有一个类的成员变量需要共享，希望在使用时保留，没有用到时就delete掉，那要怎么设计？ 　　假设我们有共享数据share_data，对象A,B,C有指向该share_data,如果我们只是在析构函数中单方面地释放关联的share_data，比如A不再需要share_data,并且单方面释放了share_data，那会造成一个问题：B和C还...
【C++】浅拷贝与深拷贝
最新发布
2402_82689232的博客
08-23 680
本篇文章介绍了string类中深拷贝、浅拷贝，以及如何实现的相关知识，欢迎大家评论交流！
C++引用计数
crossoverpptx的博客
06-30 1386
引用计数（reference count）的核心思想是使用一个计数器来标识当前指针指向的对象被多少类的对象所使用（即记录指针指向对象被引用的次数）。它允许有多个相同值的对象共享这个值的实现。引用计数的使用常有两个目的：简化跟踪堆中（也即C++中new出来的）的对象的过程。一旦一个对象通过调用new被分配出来，记录谁拥有这个对象是很重要的，因为其所有者要负责对它进行delete。但是对象所有者可以有多个，且所有权能够被传递，这就使得内存跟踪变得困难。引用计数可以跟踪对象所有权，并能够自动销毁对象。
【转】c++中的引用计数
12-08 819
C++引用计数设计与分析(解决垃圾回收问题).docx
11-24
`CRefCount`类的构造函数初始化指针和计数器，拷贝构造函数确保新对象共享原始对象的数据，同时增加原始对象的引用计数。`AddRef()`方法增加计数器，`ReleaseRef()`方法减少计数器，并在计数器为0时释放内存。析构...
C++ 引用计数技术及智能指针的简单实现
12-22
智能指针是C++编程中用来自动管理动态内存的一种机制，它的主要目标是解决C++中手动内存管理带来的问题，如内存泄漏和悬垂指针。引用计数是智能指针实现中的关键技术之一，用于追踪对象被引用的次数，从而决定何时...
c++实现引用计数
肩上风骋的博客
11-11 2257
概述 当有指针指向同一块内存空间时，计数器加1，没增加一个指向该内存空间的指针，计数器加1，同理，当原本指向该内存空间的指针指向另一块内存，计数器减1，被指向的另一个内存的计数器加1。下面是一个引用计数的一种实现。 示例 直接上代码，总共分为三部分，第一部分是基本类的定义，第二部分是对于基本类的使用类，第三部分是实现真正的引用计数功能。 // ReferenceCount.cpp : 定义控制台应用程序的入口点。 // #include "stdafx.h" #include <stdlib.h&g
C++ 引用计数
10-21 8278
C++没有像java那样的垃圾回收机制，但是我们可以实现一个。一种很简单的方式就是使用引用计数。它实际上是一种用对象来管理资源的方式，因为普通的栈上的对象在离开作用域时会调用对应的析构函数，根据这个特性，可以实现用于对指针进行管理的类。 下面以一个对int*指针的管理来说明引用计数是如何实现的。 当我们创建一个int型指针时：int *p=new int(10); 在最后我们需要调用dele
c++引用计数实现
chivalry
11-11 3726
#include #include using namespace std; class String { public: String(const char *pdata); String(const String &rhs); String &operator = (const String &rhs); ~String(); private:
引用计数
热门推荐
armman的专栏
07-29 1万+
引用计数是这样一个技巧，它允许多个有相同值的对象共享这个值的实现。这个技巧有两个常用动机。第一个是简化跟踪堆中的对象的过程。一旦一个对象通过调用new被分配出来，最要紧的就是记录谁拥有这个对象，因为其所有者－－并且只有其所有者－－负责对这个对象调用delete。但是，所有权可以被从一个对象传递到另外一个对象（例如通过传递指针型参数），所以跟踪一个对象的所有权是很困难的。象auto_ptr这样的
c++中的引用计数
daojin505的专栏
04-29 119
#ifndef SHARED_PTR_H_ #define SHARED_PTR_H_ #ifndef NULL #define NULL 0 #endif namespace util { template &lt;class T&gt; ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

十月旧城

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值