c++智能指针与引用计数

很难绷得住

已于 2022-08-08 16:45:04 修改

阅读量1.7k

点赞数 1

分类专栏： C++进阶文章标签： c++ visual studio 开发语言

于 2022-01-17 18:19:15 首次发布

本文链接：https://blog.csdn.net/qq_42567607/article/details/122520696

版权

C++进阶专栏收录该内容

17 篇文章 5 订阅

订阅专栏

一、引用计数

先写一个简单的学生类

#include<iostream>
#include <string.h>
using namespace std;

class student
{
public:
	student(const char*nam);
	student(student& s1);
	student& operator=(student& s1);
	void show();

private:
    char* name;
};
student::student(const char* nam)
{
	name = new(char[24]);
	strcpy_s(name,24, nam);
}
student::student(student& s1)
{
	//浅拷贝
	name = s1.name;
	//深拷贝
	//name = new(char[24]);
	//strcpy_s(name, 24, s1.name);
}
student& student::operator=(student& s1)
{
	//浅拷贝
	name = s1.name;
	//深拷贝
	//name = new(char[24]);
	//strcpy_s(name, 24, s1.name);
	return *this;
}
void student::show()
{
	cout << (void*)name << endl;
}
void main()
{
	student s1("mike");
	student s2 = s1;
	student s3(s1);
	s1.show();
	s2.show();
	s3.show();
}

其中的
name = s1.name;
即为浅拷贝，将要构造的对象的私有成员指针指向传进来的参数对象的私有成员指针所指向的空间
还有一点注意的是：cout << (void*)name << endl;将char指针转换成其他类型指针再cout，不然只能输出字符串的内容
在这里插入图片描述
在main中建立了三个对象，使用一次复制构造函数，一次重载的=，其中的拷贝方式皆为浅拷贝，可以看到其中的指针成员都指向同一空间

现在在析构函数中添加对该指针指向空间的释放功能
并打印name地址

student::~student()
{
	delete name;
	cout << "~Student " << (void*)name << endl;
}

可以看到，当进程结束开始清理自动变量时，先清理s1，开辟的00B29F38这块空间被清理掉，调用s2析构函数中的delet时将会出错弹出
在这里插入图片描述
为了解决这个问题，我们可以让调用复制构造函数或者重载的=时开辟一块新的内存给新对象中的指针，而不是使用之前的内存块，这叫深拷贝

name = new(char[24]);
strcpy_s(name, 24, s1.name);

可以发现此时开辟的空间不一样并且可以成功调用析构
在这里插入图片描述
深拷贝不会造成内存泄漏，但是占用空间大
浅拷贝占用空间小，但会造成内存泄漏
此时加入一个资源计数器
比喻：
浅拷贝：班里有个空调，所有同学共用空调，省钱，但是有一个同学离开教室就把空调关上
深拷贝：一人一个空调
资源计数器：有人进教室了资源计数器加1，有人离开教室了资源计数器减1，当资源计数器为0时关闭空调
资源计数器不能使用类中的static类型的原因：因为对于一个类可能通过构造函数创建多个原创的对象，每个对象及其复制都要使用同一个并且不同与其他原创对象的资源计数器

于是我们对以下地方进行修改：

class student
{
public:
	student(const char*nam);
	student(student& s1);
	student& operator=(student& s1);
	void show();
	~student();

private:
    char* name;
	int* zyct;
};
student::student(const char* nam)
{
	name = new(char[24]);
	strcpy_s(name,24, nam);
	zyct = new int;
	*zyct = 1;
}
student::~student()
{
	(*zyct)--;
	if (*zyct == 0)
		delete name;
	cout << "~Student " << (void*)name << endl;
}
student::student(student& s1)
{
	name = s1.name;
	zyct = s1.zyct;
	*zyct++;
}
student& student::operator=(student& s1)
{
	name = s1.name;
	zyct = s1.zyct;
	*zyct++;
	return *this;
}

结果如下，可以看到一方面使用多次浅拷贝节省内存，另一方面没有造成内存泄漏
在这里插入图片描述
但是这样写存在一个问题，就是缺少兼容性，做一个简易的封装

#include<iostream>
#include <string.h>
using namespace std;

class refvalue
{
public:
	refvalue(const char* nam);
	~refvalue();

	void addref();

	char* name;
	int zyct;
};
refvalue::refvalue(const char* nam)
{
	name = new(char[24]);
	strcpy_s(name, 24, nam);
	zyct = 1;
}
refvalue::~refvalue()
{
	zyct--;
	if (zyct == 0)
		delete name;
	cout << "~Student " << (void*)name <<"引用计数: "<<zyct<< endl;
}
void refvalue::addref()
{
	zyct++;
}
class student
{
public:
	student(const char* nam);
	student(student& s1);
	student& operator=(student& s1);
	void show();
	~student();

private:
	refvalue* refv;
};
student::student(const char* nam)
{
	refv = new refvalue(nam);
}
student::~student()
{
	
	refv->~refvalue();
}
student::student(student& s1)
{
	refv = s1.refv;
	refv->addref();
}
student& student::operator=(student& s1)
{
	refv = s1.refv;
	(*refv).addref();
	return *this;
}
void student::show()
{
	cout << (void*)refv->name << endl;
}
void main()
{
	student s1("TOM");
	student s2 = s1;
	student s3(s1);
	s1.show();
	s2.show();
	s3.show();
}

1.将引用计数声明为一个类而非结构体，类成员默认为private，为了在类外更方便地进行访问，将成员设置为public
2.指向类的指针pt，访问该类成员a的方法：pt->a or (*pt).a
pt.a是错的，因为’ . '前面应是一个实例化对象
3.调用顺序如下：
student类构造函数->引用技术类构造函数->student类析构->引用技术类析构
3.引用计数类计数的是name的数量，每次调用引用技术类的析构时通过判断资源计数器是否为0来判断是否释放掉name的空间，将name传给引用技术类相当于学生走进教室。
3.学生类与引用计数通过学生类中指向引用计数类的指针来建立连接，在通过构造函数创建学生类时使用new开辟一个引用计数类的空间，该空间大小通过实例化一个引用计数类来计算，实例化需要构造函数：
refv = new refvalue(nam);

结果如下：
复制的对象占用同一空间，当析构第一个对象时，在调用引用计数类的析构函数时因为其引用计数为2，所以不会删掉name的空间，析构第二个对象时同理，析构第三个对象时，由于引用计数为0在调用引用计数类的析构函数时其引用为0，所以释放掉name指向的空间
在这里插入图片描述

引用计数这种计数是为了使用浅拷贝节省内存时防止内存泄露而产生的。基本想法是让引用计数类（refvalue）来负责动态分配对象（name）的创建（new）和清理（delete），对于动态分配的对象（name），进行引用计数，每当增加一次对同一个对象的引用，那么引用对象的引用计数就会增加一次，每删除一次引用，引用计数就会减一，当一个对象的引用计数减为零时，就自动删除指向的堆内存。

基于引用计数的想法,C++11中引入了智能指针，更加方便，
如下，对于动态分配的对象（指针p）将其控制权转交给智能指针

二、智能指针概述

基于引用计数的想法,C++11中引入了智能指针，更加方便，
如下，对于动态分配的对象（指针p）将其转交给智能指针

#include<iostream>
#include <Windows.h>
using namespace std;

void cmem()
{
	while (1)
	{
		
		double* p = new double[1024 * 1024 ];//8M
		cout << p<<endl;
		Sleep(3000);
	}
}
void main()
{
	cmem();
	cin.get();
}

在死循环中不断用new开辟一个80M的内存空间，用new开辟的空间需要用delete来释放，但这里没有释放，内存空间占用将不断增加，并且造成了内存泄漏。
在这里插入图片描述

这里找了一些连续的内存空间，但由于要内存对齐，每两个地址间差值为8m多一点

void autoptr()//老版的
{
	while (1)
	{
		double* p ( new double[1024 * 1024]);//8M
		auto_ptr<double>auto_ptr(p);//接管这块内存，自动回收
		Sleep(3000);
	}
}

先用new开辟一块内存，用p指向这块内存，通过p做为参数将这块内存让智能指针来接管，即使没有delete也可以在一个循环结束时自动释放这块内存
在这里插入图片描述
关于进程的内存空间划分：
图片来源：https://www.bilibili.com/video/BV1tq4y1s784?p=3

三、 unique_ptr

特性1：

void main()
{
	int* p1 = new int;
	auto_ptr<int>p2(p1);
	auto_ptr<int>p3 = p2;
}

此时不会报错，将p2赋值给p3，即这块空间的所有权仅归p3所有，p2此时管理的是一片虚无之地，想要踏足这片虚无之地将会引来无法预知的灾难：

void main()
{
	int* p1 = new int;
	auto_ptr<int>p2(p1);
	auto_ptr<int>p3 = p2;
	cout << *p2;
}

在这里插入图片描述

所以auto_ptr的缺点是：存在潜在的内存崩溃问题，在C++11中，auto_ptr已经被舍弃，转而使用更安全的unique_ptr：
在这里插入图片描述
可以看到即使冒险者没有去探险，编译器也能发现这块虚无之地，更加的安全
特性2：
unique_ptr正如其名：unique独一无二的，实现独占式拥有或严格拥有概念，保证同一时间内只有一个只能指针指向该对象：

void main()
{
	int* p1 = new int;
	unique_ptr<int>p2(p1);
	unique_ptr<int>p3(p1);
}

在这里插入图片描述

四、shared_ptr共享型，强引用

shared_ptr实现共享拥有概念，多个shared_ptr可以指向相同对象（通过已构造好的shared_ptr做为下一个shared_ptr的参数），使用引用计数机制来表明资源被几个指针共享
使用原始指针创建 shared_ptr 对象：

void main()
{
	int* p1 = new int;
	shared_ptr<int>p2(p1);
	cout << "p1这个资源的所有者个数： " << p2.use_count()<<endl;
	shared_ptr<int>p3(p2);
	//或者shared_ptr<int>p3(p1);
	cout << "p1这个资源的所有者个数： "<<p3.use_count()<<endl;
	p3.reset();
	cout << "p1这个资源的所有者个数： " << p2.use_count()<<endl;
}

先让p2来管理p1这块内存，然后使用shared_ptr的成员函数use_count（）来查看资源的所有者个数，此时个数为1，
再让p3也指向这块内存，此时查看资源所有者个数为2，
让p3调用成员函数reset（），p3会释放资源所有权，p3置nullptr，引用计数减一，当计数为0时，资源会被释放，此时再查看资源所有者个数为时：
在这里插入图片描述
如果没有这个reset()时：p2和p3位临时变量，存放在栈中，在该段末尾时，后入栈的p3先调用析构，此时引用计数-1为1，p2析构时引用计数再减1，然后释放掉p1的空间。

因为带有参数的 shared_ptr 构造函数是 explicit 类型的，所以不能像这样std::shared_ptr p1 = new int();隐式调用它构造函数。创建新的shared_ptr对象的最佳方法是使用std :: make_shared：

创建空的 shared_ptr 对象

std::shared_ptr<int> p1 = std::make_shared<int>();

std::make_shared 一次性为int对象和用于引用计数的数据都分配了内存，而new操作符只是为int分配了内存。

五、weak_ptr 弱引用

	class Node
	{
	public:
		shared_ptr<Node> sp_parent;
		shared_ptr<Node> sp_child;

		int* chengyuan = new int[1024 * 1024*2];
		void setparent(shared_ptr<Node> p)
		{
			sp_parent = p;
		}

		void setchild(shared_ptr<Node> c)
		{
			sp_child = c;
		}

		~Node()
		{
			delete chengyuan;
			cout << "~Node()" << endl;
		}
	};

	int main()
	{
		{
			shared_ptr<Node> parent(new Node());				// sp1
			shared_ptr<Node> child(new Node());					// sp2
			parent->setchild(child);
			child->setparent(parent);
		}
		while (1);
	}

代码说明：
先在堆上new了两个node，一个node用shared_ptr型指针parent管理，一个node用shared_ptr型指针child管理，通过重载的->可以访问管理空间中的成员，parent指针调用其中的setchild函数成员，该函数可以将node类中的shared_ptr sp_parent去管理参数传进来的指针所管理的空间，即sp_parent去管理第二次new时的空间，child指针调用其中的setparent函数成员也是如此。
代码中各个对象的关系如下图所示，parent和child是堆上两个node对象，分别用shared_ptr sp1和sp2管理，其内部也通过sp_child和sp_parent相互引用，这种成环引用的结果是parent和child的引用计数永远不会变成0，也就不会被delete。
在这里插入图片描述
图片参考：https://www.csdn.net/tags/OtTaggxsMzgxNTQtYmxvZwO0O0OO0O0O.html

int* chengyuan = new int[1024 * 1024*2];

int是4个字节，因此这块空间new了4×1024×1024×2=8字节×1024×1024=16KB×1024=8MB，两个new就是16mb，再加上内核空间区，共享区等就约是18MB，当退出栈区时两个shared_ptr相互引用，资源不会被释放：
在这里插入图片描述
我们需要把sp_child和sp_parent中的至少一个改用weak_ptr来破坏成环引用。假如sp_child改用weak_ptr wp_child，那么child只被sp2拥有：
1、当sp1、sp2被销毁时，parent引用计数变为1，child的引用计数变为0；
2、child被delete，所以sp_parent被销毁，parent引用计数变为0；
3、parent被delete。

注意，相互引用的是结点中的shaerd_ptr成员，要将该成员改为weak_ptr：

class Node
	{
	public:
		shared_ptr<Node> sp_parent;
		weak_ptr<Node> sp_child;

		int* chengyuan = new int[1024 * 1024*2];
		void setparent(shared_ptr<Node> p)
		{
			sp_parent = p;
		}

		void setchild(shared_ptr<Node> c)
		{
			sp_child = c;
		}

		~Node()
		{
			delete chengyuan;
			cout << "~Node()" << endl;
		}
	};

	int main()
	{
		{
			shared_ptr<Node> parent(new Node());				// sp1
			shared_ptr<Node> child(new Node());					// sp2
			parent->setchild(child);
			child->setparent(parent);
		}
		while (1);
	}

可以看到析构函数被调用，new的对象也被清理：
在这里插入图片描述

很难绷得住

关注

1
点赞
踩
3

收藏

觉得还不错? 一键收藏
0
评论
c++智能指针与引用计数

先在堆上new了两个node，一个node用shared_ptr型指针parent管理，一个node用shared_ptr型指针child管理，通过重载的->可以访问管理空间中的成员，parent指针调用其中的setchild函数成员，该函数可以将node类中的shared_ptr sp_parent去管理参数传进来的指针所管理的空间，即sp_parent去管理第二次new时的空间，child指针调用其中的setparent函数成员也是如此。代码中各个对象的关系如下图所示，parent和chi......
复制链接

扫一扫