C++ 智能指针简单实现和循环引用问题解决

最新推荐文章于 2023-03-28 22:14:45 发布
最新推荐文章于 2023-03-28 22:14:45 发布
阅读量465 收藏 1
点赞数
分类专栏： C/C++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/luomogenhaoqi/article/details/89351863
版权

参考：

https://baike.baidu.com/item/%E6%99%BA%E8%83%BD%E6%8C%87%E9%92%88/10784135?fr=aladdin

https://baike.baidu.com/item/%E5%8F%A5%E6%9F%84%E7%B1%BB/358880?fr=aladdin

https://blog.csdn.net/zhangye3017/article/details/80429780

当类中有指针成员时，一般有两种方式来管理指针成员：一是采用值型的方式管理，每个类对象都保留一份指针指向的对象的拷贝；另一种更优雅的方式是使用智能指针，从而实现指针指向的对象的共享。

智能指针(smart pointer)的一种通用实现技术是使用引用计数(reference count)。智能指针类将一个计数器与类指向的对象相关联，引用计数跟踪该类有多少个对象的指针指向同一对象。

原理

每次创建类的新对象时，初始化指针并将引用计数置为1；当对象作为另一对象的副本而创建时，拷贝构造函数拷贝指针并增加与之相应的引用计数；对一个对象进行赋值时，赋值操作符减少左操作数所指对象的引用计数（如果引用计数为减至0，则删除对象），并增加右操作数所指对象的引用计数；调用析构函数时，析构函数减少引用计数（如果引用计数减至0，则删除基础对象）。

实现代码如下：

// ConsoleApplication.cpp : Defines the entry point for the console application.
//

#include "stdafx.h"
#include <stdio.h>
#include<stdlib.h>
#include<iostream> 

class TestP//实际原始对象类
{
public:
	TestP(int a, int b) :m(a), n(b) {}
	int GetM() const { return m; };
	int GetN() const { return n; };
	void SetM(int v) { m = v; };
	void SetN(int v) { n = v; };

private:
	int m, n;
};

class UPoint//引用计数器类 存放实际原始对象和引用
{
private:
	friend class HandlePtr;//声明HandlePtr为UPoint友元类 
	UPoint(TestP *TP) :p(TP), RefCout(1) {} //每次创建类的新对象时，初始化指针并将引用计数置为1；
	~UPoint() { delete p; }
	int RefCout;//引用计数器
	TestP *p;//指向实际原始对象
};

class HandlePtr//智能指针类 存储和管理所指对象 操作UPoint
{
public:
	HandlePtr(TestP *TP) :UP(new UPoint(TP)) {};//智能指针类 默认有参数构造函数 传入实际原始对象TestP
	HandlePtr(const HandlePtr &HP) :UP(HP.UP) { ++UP->RefCout; }//拷贝构造函数 当对象作为另一对象的副本而创建时，拷贝构造函数拷贝指针并增加与之相应的引用计数；
	HandlePtr& operator=(const HandlePtr &R_HP)//对一个对象进行赋值时，赋值操作符减少左操作数所指对象的引用计数（如果引用计数为减至0，则删除对象），并增加右操作数所指对象的引用计数；
	{
		++R_HP.UP->RefCout;
		if (--UP->RefCout == 0)
			delete UP;
		UP = R_HP.UP;
		return *this;
	}
	
	~HandlePtr()//调用析构函数时，析构函数减少引用计数（如果引用计数减至0，则删除基础对象）。
	{
		if (--UP->RefCout == 0)
			delete UP;
		else
		std::cout << "剩余" << UP->RefCout << "个指针指向原始对象" << std::endl;
	}

	//重载* -> 智能指针就可以实际原始对象使用* ->
	TestP& operator*()//重载运算符*
	{
		return *(UP->p);
	}
	TestP* operator->()//重载运算符->
	{
		return UP->p;
	}

private:

	UPoint *UP;//引用计数器类对象，通过管理UPoint 达到管理 实际原始对象TestP
};

int main()
{
	TestP *P = new TestP(5, 6);
	{
		HandlePtr HP1(P);//这时RefCout=1
		{
			HandlePtr HP2(HP1);//这时RefCout=2
			{
				HandlePtr HP3 = HP1;//这时RefCout=3
			}
			//HP3作用域外回收 这时RefCout=2
		}
		//HP2作用域外回收 这时RefCout=1
	}
	//HP1作用域外回收 这时RefCout=0 释放内存

	std::cout << P->GetM() << std::endl;

	TestP *PP = new TestP(10, 11);
	HandlePtr _HP(PP);
	std::cout << _HP->GetM() << std::endl;
	std::cout << (*_HP).GetN() << std::endl;

	system("pause");
    return 0;
}

 

使用模版智能指针类实现如下：

// ConsoleApplication.cpp : Defines the entry point for the console application.
//

#include "stdafx.h"
#include <stdio.h>
#include<stdlib.h>
#include<iostream> 

class TestP//实际原始对象类
{
public:
	TestP(int a, int b) :m(a), n(b) {}
	int GetM() const { return m; };
	int GetN() const { return n; };
	void SetM(int v) { m = v; };
	void SetN(int v) { n = v; };

private:
	int m, n;
};

template <typename T>
class HandlePtr;//前置声明

template <typename T>
class UPoint//引用计数器类 存放实际原始对象和引用
{
private:
	friend class HandlePtr<T>;//声明HandlePtr为UPoint友元类 
	UPoint(T *TP) :p(TP), RefCout(1) {} //每次创建类的新对象时，初始化指针并将引用计数置为1；
	~UPoint() { delete p; }
	int RefCout;//引用计数器
	T *p;//指向实际原始对象
};

template <typename T>
class HandlePtr//智能指针类 存储和管理所指对象 操作UPoint
{
public:
	HandlePtr(T *TP) :UP(new UPoint<T>(TP)) {};//智能指针类 默认有参数构造函数 传入实际原始对象TestP
	HandlePtr(const HandlePtr &HP) :UP(HP.UP) { ++UP->RefCout; }//拷贝构造函数 当对象作为另一对象的副本而创建时，拷贝构造函数拷贝指针并增加与之相应的引用计数；
	HandlePtr& operator=(const HandlePtr &R_HP)//对一个对象进行赋值时，赋值操作符减少左操作数所指对象的引用计数（如果引用计数为减至0，则删除对象），并增加右操作数所指对象的引用计数；
	{
		++R_HP.UP->RefCout;
		if (--UP->RefCout == 0)
			delete UP;
		UP = R_HP.UP;
		return *this;
	}
	
	~HandlePtr()//调用析构函数时，析构函数减少引用计数（如果引用计数减至0，则删除基础对象）。
	{
		if (--UP->RefCout == 0)
			delete UP;
		else
		std::cout << "剩余" << UP->RefCout << "个指针指向原始对象" << std::endl;
	}

	//重载* -> 智能指针就可以实际原始对象使用* ->
	T& operator*()//重载运算符*
	{
		return *(UP->p);
	}
	T* operator->()//重载运算符->
	{
		return UP->p;
	}

private:

	UPoint<T> *UP;//引用计数器类对象，通过管理UPoint 达到管理 实际原始对象TestP
};

int main()
{
	TestP *P = new TestP(5, 6);
	{
		HandlePtr<TestP> HP1(P);//这时RefCout=1
		{
			HandlePtr<TestP> HP2(HP1);//这时RefCout=2
			{
				HandlePtr<TestP> HP3 = HP1;//这时RefCout=3
			}
			//HP3作用域外回收 这时RefCout=2
		}
		//HP2作用域外回收 这时RefCout=1
	}
	//HP1作用域外回收 这时RefCout=0 释放内存

	std::cout << P->GetM() << std::endl;

	TestP *PP = new TestP(10, 11);
	HandlePtr<TestP> _HP(PP);
	std::cout << _HP->GetM() << std::endl;
	std::cout << (*_HP).GetN() << std::endl;

	system("pause");
    return 0;
}

上面这种是通过辅佐类UPoint类操作实际原始对象和引用计数器实现，以下方法通过句柄类操作实际原始对象和引用计数器实现，代码如下：

// ConsoleApplication.cpp : Defines the entry point for the console application.
//

#include "stdafx.h"
#include <stdio.h>
#include<stdlib.h>
#include<iostream> 

class TestP//实际原始对象类
{
public:
	TestP(int a, int b) :m(a), n(b) {}
	int GetM() const { return m; };
	int GetN() const { return n; };
	void SetM(int v) { m = v; };
	void SetN(int v) { n = v; };

private:
	int m, n;
};


template <typename T>
class HandlePtr//智能指针类 存储和管理所指对象 
{
 
public:
	HandlePtr(T *TP) :p(TP), RefCout(new int(1)){};//智能指针类 默认有参数构造函数 传入实际原始对象 并将引用计数置为1
	HandlePtr(const HandlePtr &HP) :p(HP.p), RefCout(HP.RefCout) 
	{
		++(*RefCout);//拷贝构造函数 当对象作为另一对象的副本而创建时，拷贝构造函数拷贝指针并增加与之相应的引用计数；
	}
	HandlePtr& operator=(const HandlePtr &R_HP)//对一个对象进行赋值时，赋值操作符减少左操作数所指对象的引用计数（如果引用计数为减至0，则删除对象），并增加右操作数所指对象的引用计数；
	{
		if (this != &R_HP)
		{
			++(*(R_HP.RefCout));
			if (--(*RefCout) == 0)
			{
				delete p;
				delete RefCout;
			}

			p = R_HP.p;
			RefCout = R_HP.RefCout;

		}
		
		return *this;
	}
	
	~HandlePtr()//调用析构函数时，析构函数减少引用计数（如果引用计数减至0，则删除基础对象）。
	{
		if (--(*RefCout) == 0)
		{
			delete p;
			delete RefCout;
		}
		
		else
		std::cout << "剩余" << *RefCout << "个指针指向原始对象" << std::endl;
	}

	//重载* -> 智能指针就可以实际原始对象使用* ->
	T& operator*()//重载运算符*
	{
		return *(p);
	}
	T* operator->()//重载运算符->
	{
		return p;
	}

private:
	int* RefCout;//引用计数器
	T *p;//指向实际原始对象
};

int main()
{
	TestP *P = new TestP(5, 6);
	{
		HandlePtr<TestP> HP1(P);//这时RefCout=1
		{
			HandlePtr<TestP> HP2(HP1);//这时RefCout=2
			{
				HandlePtr<TestP> HP3 = HP1;//这时RefCout=3
			}
			//HP3作用域外回收 这时RefCout=2
		}
		//HP2作用域外回收 这时RefCout=1
	}
	//HP1作用域外回收 这时RefCout=0 释放内存

	std::cout << P->GetM() << std::endl;

	TestP *PP = new TestP(10, 11);
	HandlePtr<TestP> _HP(PP);
	std::cout << _HP->GetM() << std::endl;
	std::cout << (*_HP).GetN() << std::endl;

	system("pause");
    return 0;
}

智能指针问题：循环引用问题，实现描述循环引用问题代码如下:

// ConsoleApplication.cpp : Defines the entry point for the console application.
//

#include "stdafx.h"
#include <stdio.h>
#include<stdlib.h>
#include<iostream> 




template <typename T>
class HandlePtr//智能指针类 存储和管理所指对象 
{
 
public:
	HandlePtr(T *TP) :p(TP), RefCout(new int(1)){};//智能指针类 默认有参数构造函数 传入实际原始对象 并将引用计数置为1
	HandlePtr(const HandlePtr &HP) :p(HP.p), RefCout(HP.RefCout) 
	{
		++(*RefCout);//拷贝构造函数 当对象作为另一对象的副本而创建时，拷贝构造函数拷贝指针并增加与之相应的引用计数；
	}
	HandlePtr& operator=(const HandlePtr &R_HP)//对一个对象进行赋值时，赋值操作符减少左操作数所指对象的引用计数（如果引用计数为减至0，则删除对象），并增加右操作数所指对象的引用计数；
	{
		if (this != &R_HP)
		{
			++(*(R_HP.RefCout));
			if (--(*RefCout) == 0)
			{
				delete p;
				delete RefCout;
			}

			p = R_HP.p;
			RefCout = R_HP.RefCout;

		}
		
		return *this;
	}
	
	~HandlePtr()//调用析构函数时，析构函数减少引用计数（如果引用计数减至0，则删除基础对象）。
	{
		if (--(*RefCout) == 0)
		{
			std::cout << "已经销毁原始对象" << std::endl;
			delete p;
			delete RefCout;
		}
		else
		std::cout << "剩余" << *RefCout << "个指针指向原始对象" << std::endl;
	}

	//重载* -> 智能指针就可以实际原始对象使用* ->
	T& operator*()//重载运算符*
	{
		return *(p);
	}
	T* operator->()//重载运算符->
	{
		return p;
	}

private:
	int* RefCout;//引用计数器
	T *p;//指向实际原始对象
};


class TestP//实际原始对象类
{
public:
	HandlePtr<TestP> _A;
	HandlePtr<TestP> _B;

	TestP()
		:_A(NULL)
		, _B(NULL)
	{}

	~TestP()
	{
		std::cout << "delete TestP" << std::endl;
	}
};

void TestRefCycle()
{
	//A B里成员对象都互相指向，循环引用
	HandlePtr<TestP> A = new TestP();
	HandlePtr<TestP> B = new TestP();
	A->_B = B;
	B->_A = A;
}

int main()
{
	TestRefCycle();
	//在函数TestRefCycle执行后，并没有销毁原始对象，打印日志：
	//剩余1个指针指向原始对象
	//剩余1个指针指向原始对象
	//  A B互相等对方释放 导致最终都没能释放，内存泄漏
	system("pause");
    return 0;
}

解决智能指针循环引用问题：通过弱指针，弱指针仅指向原始对象不操作引用计数（引用计数不增加），这样就解决循环引用没有释放内存问题了，实现代码如下：

// ConsoleApplication.cpp : Defines the entry point for the console application.
//

#include "stdafx.h"
#include <stdio.h>
#include<stdlib.h>
#include<iostream> 



template<typename T>
class HandleWeakPtr;//前置声明

template <typename T>
class HandlePtr//智能指针类 存储和管理所指对象 
{
	friend class HandleWeakPtr<T>;//HandleWeakPtr 为 HandlePtr友元类   弱指针HandleWeakPtr可以访问HandlePtr
public:
	HandlePtr(T *TP) :p(TP), RefCout(new int(1)){};//智能指针类 默认有参数构造函数 传入实际原始对象 并将引用计数置为1
	HandlePtr(const HandlePtr &HP) :p(HP.p), RefCout(HP.RefCout) 
	{
		++(*RefCout);//拷贝构造函数 当对象作为另一对象的副本而创建时，拷贝构造函数拷贝指针并增加与之相应的引用计数；
	}
	HandlePtr& operator=(const HandlePtr &R_HP)//对一个对象进行赋值时，赋值操作符减少左操作数所指对象的引用计数（如果引用计数为减至0，则删除对象），并增加右操作数所指对象的引用计数；
	{
		if (this != &R_HP)
		{
			++(*(R_HP.RefCout));
			if (--(*RefCout) == 0)
			{
				delete p;
				delete RefCout;
			}

			p = R_HP.p;
			RefCout = R_HP.RefCout;

		}
		
		return *this;
	}
	
	~HandlePtr()//调用析构函数时，析构函数减少引用计数（如果引用计数减至0，则删除基础对象）。
	{
		if (--(*RefCout) == 0)
		{
			std::cout << "已经销毁原始对象" << std::endl;
			delete p;
			delete RefCout;
		}
		else
		std::cout << "剩余" << *RefCout << "个指针指向原始对象" << std::endl;
	}

	//重载* -> 智能指针就可以实际原始对象使用* ->
	T& operator*()//重载运算符*
	{
		return *(p);
	}
	T* operator->()//重载运算符->
	{
		return p;
	}

private:
	int* RefCout;//引用计数器
	T *p;//指向实际原始对象
};


// 弱指针仅指向原始对象不操作引用计数（不在管理和释放原始对象，引用计数不增加，解决了循环引用的问题）
template<typename T>
class HandleWeakPtr
{
public:
	HandleWeakPtr(HandlePtr<T>& HP)//HandleWeakPtr构造函数 参数传入HandlePtr对象
		:p(HP.p)    //通过参数HandlePtr对象 指向实际原始对象
	{}

	HandleWeakPtr(const HandlePtr<T> &HP)
	{
		p = HP.p;
	}
	HandleWeakPtr& operator=(const HandlePtr<T> &R_HP)
	{
		p = R_HP.p;
		return *this;
	}

	HandleWeakPtr()
		:p(NULL)
	{}

	//重载* -> 弱指针就可以实际原始对象使用* ->
	T& operator*()//重载运算符*
	{
		return *p;
	}
	T* operator->()//重载运算符->
	{
		return p;
	}
protected:
	T * p;
};


class TestP//实际原始对象类
{
public:

	//使用弱指针 不操作引用计数器
	HandleWeakPtr<TestP> _A;
	HandleWeakPtr<TestP> _B;

	~TestP()
	{
		std::cout << "delete TestP" << std::endl;
	}
};


void TestRefCycle()
{
	//A B里成员对象都互相指向，循环引用
	HandlePtr<TestP> A = new TestP();
	HandlePtr<TestP> B = new TestP();
	A->_B = B;
	B->_A = A;
}

int main()
{
	TestRefCycle();
	//在函数TestRefCycle执行后，并没有销毁原始对象，打印日志：
	//已经销毁原始对象
    //delete TestP
	//已经销毁原始对象
    //delete TestP
	//  A B通过弱指针不增加引用计数器 所以都销毁对象 A B了
	system("pause");
    return 0;
}

 

落寞根号七
关注
专栏目录
C++智能指针循环引用解决
12-22
总结一下，解决C++智能指针循环引用的关键在于使用`weak_ptr`。`weak_ptr`不增加对象的引用计数，从而避免了循环引用导致的内存泄漏。当需要访问`weak_ptr`指向的对象时，可以通过`lock()`方法获取一个临时的`shared...
[C++] 智能指针及循环引用问题
wangmj_hdu的博客
10-14 1984
C++智能指针介绍 由于C++没有自动回收内存机制，程序员每次new出来的内存需要手动delete，流程太复杂，忘记delete，会造成内存泄露。所以C++引入了智能指针，智能指针可用于动态资源管理。 智能指针在memory头文件的std命名空间中定义。 更具体的智能指针介绍可以参考我这篇博客：C++11新特性智能指针 C++智能指针的类别 C++11中的：unique_ptr、shared_ptr、weak_ptr C++98中的：auto_ptr unique_ptr 只允许基础指针的一个所有者。可以移
C++中的智能指针
KangRoger的专栏
05-22 1562
当设计含有指针的类时，应特别
C++类析构顺序与创建顺序相反(智能指针版)，构造时先构造成员后构造自身
最新发布
weixin_48031922的博客
03-28 201
C++11智能指针版例子，类析构顺序与创建顺序相反，类构造时先构造成员后构造自身。
C++多线程编程
lly_117的博客
07-13 400
创建线程 在Windows平台，Windows API提供了对多线程的支持。 CreateThread用于创建一个线程，其函数原型如下： HANDLE WINAPI CreateThread( LPSECURITY_ATTRIBUTES lpThreadAttributes, //线程安全相关的属性，常置为NULL SIZE_T
C++智能指针及循环引用
m0_48643365的博客
07-03 1655
目录： auto_ptr unique_ptr shared_ptr weak_ptr 循环引用问题 智能指针的原理： 智能指针的原理：智能指针是一个类，这个类的构造函数中传入一个普通指针，析构函数中释放传入的指针指向的内存。智能指针本身是栈上的对象，所以当函数（程序）结束时会被自动释放掉。 1） auto_ptr：不支持复制和赋值，但复制和赋值时不提示错误，不能放入容器中。 2）unique_ptr:独享指针，不支持复制和赋值，但是赋值会编译出错。提供move方法。 3）shared_ptr：共享指针
C++：智能指针、auto、范围for、lambda匿名函数
m0_69414302的博客
07-18 670
​ 在早期C/C++中auto的含义是：使用auto修饰的变量，是具有自动存储器的局部变量 C++11中，标准委员会赋予了auto全新的含义即：auto不再是一个存储类型指示符，而是作为一个新的类型指示符来指示编译器，auto声明的变量必须由编译器在编译时期推导而得。 ​.........
C++智能指针循环引用问题分析.pdf
02-27
C++智能指针是C++11引入的重要特性，它们主要分为三种类型：`shared_ptr`、`weak_ptr`和`unique_ptr`。这些智能指针设计的目标是帮助程序员更安全地管理动态分配的内存，从而减少内存泄漏的风险。本文将深入探讨智能...
C++智能指针的原理和实现.pdf
02-27
智能指针的引入主要是为了解决传统C++中动态内存管理的问题，如内存泄漏和二次释放等。传统的内存管理使用`new`来分配内存，`delete`来释放内存，但这种手动管理方式容易出错。智能指针通过在构造时获取资源并在析构...
c++11之智能指针以及循环引用的解决
JMW1407的博客
06-08 1231
C++ 11之智能指针背景智能指针的引出实例unique_ptr、share_ptr、weak_ptrunique_ptr 背景 理解智能指针需要从下面三个层次： 1、从较浅的层面看，智能指针是利用了一种叫做RAII（资源获取即初始化）的技术对普通的指针进行封装，这使得智能指针实质是一个对象，行为表现的却像一个指针。 2、智能指针的作用是防止忘记调用delete释放内存和程序异常的进入catch块忘记释放内存。另外指针的释放时机也是非常有考究的，多次释放同一个指针会造成程序崩溃，这些都可以通过智能指针来解决
C++学习Day09——控制循环及指针
weixin_44176958的博客
11-04 729
Day09 控制循环 控制语句主要有三个，分别为continue、break、return。他们有不同的作用。continue只能用在循环内部，他的作用简单来说就是：如果能进行下一次迭代的话直接进行下一次迭代，否则就会结束循环。break主要用在循环里面，但是它也经常出现在switch语句中，它的功能就是直接跳出循环。return可以直接完全的退出函数，如果在函数内执行到return命令就会直接完全退出函数，return是需要提供值的。 continue示例 int main(){ for (int
C++智能指针以及循环引用的解决办法
qq_34314736的博客
07-18 2658
• 1:为什么要使用智能指针 我们知道C++的内存管理是让很多人头疼的事情，当我们写一个new语句时，一般就会立即把delete语句直接也写了，但是我们不能避免程序还未执行到delete时就跳转了或者在函数中没有执行到最后的delete语句就返回了，如果我们不在每一个可能跳转或者返回的语句前释放资源，就会造成内存泄露。使用智能指针可以很大程度上的避免这个问题，因为智能指针就是一个类，当超出了类的作...
C++ 智能指针的循环引用问题
Magnum的博客
03-21 3009
首先我们要知道，循环引用问题是shared_ptr智能指针引起的。shared_ptr的一个最大的陷阱是循环引用，循环引用会导致堆内存无法正确释放，导致内存泄漏。 那么shared_ptr是如何引起循环引用的呢？ 先明确一个结论：shared_ptr智能指针管理的对象，只有在引用计数减为0的时候才会释放。 而循环引用发生的情况就是违反了上面所说的结论：引用计数不能递减到0，以...
智能指针和循环引用
Coder's Blog
08-14 724
智能指针（四个） 智能指针：实际上是一个栈上的对象，并不是一个指针类型。所有的智能指针都重载了operator -&amp;amp;amp;gt;来访问对象的引用，所以weak_ptr不能算智能指针 因为它没有重载-&amp;amp;amp;gt;和*。 RALL机制：通过利用对象的自动销毁，让资源具有了生命周期，有了自动回收的功能。 智能指针由三大版本 1. 管理权转移（std：：Autoptr） 2. 简单粗暴的防拷贝（b...
智能指针循环引用--转
09-18 114
智能指针 　　在智能指针中shared_ptr用来计算指向对象的指针的个数，但是如果先执行shared_ptr1=shared_ptr2，再执行shared_ptr2=shared_ptr1，这样shared_ptr1.count()和shared_ptr2.count()都为1，这就造成了循环引用，循环引用会导致堆内存无法正确释放，导致内存泄露。 　　考虑一个简单的对象——家长与子...
c++对象的动态创建与释放
bbs375的博客
09-22 1万+
1 new和delete基本语法 1）在软件开发过程中，常常需要动态地分配和撤销内存空间，例如对动态链表中结点的插入与删除。在C语言中是利用库函数malloc和free来分配和撤销内存空间的。C++提供了 简便而功能较强的运算符new和delete来取代malloc和free函数。 注意： new和delete是运算符，不是函数，因此执行效率高。 2）虽然为了与C语言兼容，C++仍保留ma
c++ 智能指针及 循环引用问题
热门推荐
Daniel 的技术笔记 不积跬步无以至千里，不积小流无以成江海。
04-07 2万+
c++智能指针介绍 由于 C++ 语言没有自动内存回收机制，程序员每次 new 出来的内存都要手动 delete，比如流程太复杂，最终导致没有 delete，异常导致程序过早退出，没有执行 delete 的情况并不罕见，并造成内存泄露。如此c++引入智能指针 ，智能指针即是C++ RAII的一种应用，可用于动态资源管理，资源即对象的管理策略。 智能指针在 标头文件的 std 命名空间中定义
C++智能指针：弱引用解决循环引用问题
"C++智能指针中的循环引用问题及弱引用来解决" 在C++编程中，智能指针是一种用于自动管理内存的对象，它们可以有效地防止内存泄漏，特别是当对象之间的关系复杂时。其中，`shared_ptr`是最常见的智能指针类型，它...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值