浅谈智能指针

最新推荐文章于 2025-07-14 15:31:48 发布
最新推荐文章于 2025-07-14 15:31:48 发布
阅读量581 收藏 2
点赞数 4
CC 4.0 BY-SA版权
分类专栏： C++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/qq_39755395/article/details/80094998

在说智能指针之前，我们先来看以下代码：

//文件——Smart_ptr.h
#include <iostream>
#include <vld.h>
using namespace std;

class Test
{
public:
	Test(int a = 10,int* p = NULL):ma(a),mp(p) {cout<<"Test()"<<endl;}
	~Test() {cout<<"~Test()"<<endl;}
private:
	int ma;
	int* mp;
};

//文件——Smart_ptr.cpp
#include "SmartPtr.h"

int main()
{
	int *p = new int();
	Test A(20,p);

	return 0;
}

我们使用vld工具去查看程序运行过程中是否出现内存泄露，结果如下：


    在上图中可以看到，确实发生了内存泄露。因为我们传入的指针指向的是堆上的内存块，如果在对象析构时不手动释放(delete)的话，就会发生内存泄露。那你或许会说——实现自己的析构函数、进行手动释放不就行了，答案是不行，因为当你传入的p指向的是栈上内存时，就不能使用delete去手动释放，栈上内存是系统来进行管理的。对于指针p传入的不确定性，我们就没办法解决了吗？

    答案就是——智能指针。我们都知道，栈上空间是系统分配、回收的，堆上空间是用户自己分配、回收的，那么如果能对堆上空间实现用户分配、系统自行回收的机制，就不用担心内存泄露的问题了。

    智能指针的思想：定义一个类来封装资源的分配和释放，在构造函数完成资源的分配和初始化，在析构函数中完成资源的清理和释放，可以保证资源的正确使用和释放。(资源指的是堆上资源)

    我们将讲述四个智能指针，其中scoped_ptr、shared_ptr和 weak_ptr是C++11标准从boost库引入的智能指针。

一、auto_ptr

    auto_ptr已经被摒弃了，只是为了向前兼容而被保存了下来，建议代码中不要使用该智能指针。

1.实现一
#include <iostream>
#include <vld.h>
using namespace std;

template <typename T>
class Myauto_ptr
{
public:
	Myauto_ptr(T* p):_mptr(p){}//构造函数
	Myauto_ptr(const Myauto_ptr<T>& p)//拷贝构造函数
	{
		_mptr = p._mptr;
		p._mptr = NULL;
	}
	Myauto_ptr<T>& operator=(const Myauto_ptr<T>& p)//复制运算符的可重载函数
	{
		if(this != &p)
		{
			_mptr = p._mptr;
			p._mptr = NULL;
		}
		return *this;
	}
	T& operator*()//*运算符的可重载函数
	{
		return *_mptr;
	}
	T* operator->()//->运算符的可重载函数
	{
		return _mptr;
	}
	~Myauto_ptr()
	{
		delete _mptr;
		_mptr = NULL;
	}
private:
	T* _mptr;
};

class Test
{
public:
	void Show()
	{
		cout<<"Test::show()"<<endl;
	}
};

Myauto_ptr<int> fun()
{
	Myauto_ptr<int> tmp(new int(80));
	return tmp;
}

int main()
{
	Myauto_ptr<int> pa(new int);
	*pa = 20;
	cout<<*pa<<endl;

	Myauto_ptr<int> pb(pa);
	*pb = 50;
	cout<<*pb<<endl;

	Myauto_ptr<int> pc(fun());//自定义类型的临时对象是 变量
	cout<<*pc<<endl;

	Myauto_ptr<Test> pd(new Test());
	pd->Show();

	return 0;
}
2.实现一的问题

    auto_ptr的原则是“管理权唯一，释放权唯一”。

问题一：拷贝构造函数
    A指针指向了addr内存，B指针通过 拷贝构造的方法 将A指针对addr的管理权和释放权一并拿来，而A指针这时再想去操作addr内存时，却只能崩溃(它的_mptr已经变为NULL)，这样非常不合理，A是去构造B的，自己却失去了所有东西......

 

问题二：赋值运算符的可重载函数

    A指针和B指针 都初始化指向addr内存，当用B指针去给A指针赋值时，按照步骤先将A指向的内存释放掉，A再重新指向B指向的内存，最后将B的指向置为NULL，但是A和B管理的是同一片内存，释放掉之后，B指针就是一个野指针，A得到之后去访问 或者 析构时程序就会崩溃。


3.实现二

    原则是“管理权不唯一，释放权唯一”，即可以多个auto_ptr管理同一片内存，但是只能有一个指针释放该片内存。怎么确定是哪个指针能释放呢？在成员变量中加入一个标志变量flag，flag为true则有释放权，flag为false则没有释放权。

管理权转移原则：

① 旧智能指针有释放权，新智能指针有，并且旧的置为没有

② 旧智能指针没有释放权，新智能指针也没有

#include <iostream>
using namespace std;

template <typename T>
class Myauto_ptr2
{
public:
	Myauto_ptr2(T* p)
	{
		_mptr = p;
		_flag = true;
		if(!_mptr)//_mptr==NULL
		{ 
			_flag = false;
		}
	}
	
	Myauto_ptr2(const Myauto_ptr2<T>& p)
	{
		_mptr = p._mptr;
		if(p._flag == true)
		{
			_flag = true;
			p.realease();
		}
		else
		{
			_flag = false;
		}
	}
	Myauto_ptr2<T>& operator=(const Myauto_ptr2<T>& p)
	{
		if(this != &p)
		{
			this->~Myauto_ptr2();//释放旧资源！！
			_mptr = p._mptr;
			if(p._flag == true)
			{
				_flag = true;//释放权转移
				p.realease();
			}
			else
			{
				_flag = false;
			}
		}
		return *this;
	}
	T& operator*()
	{
		return *_mptr;
	}
	T* operator->()
	{
		return _mptr;
	}
	~Myauto_ptr2()
	{
		if(_flag == true)
		{
			delete _mptr;
			_mptr = NULL;
			_flag = false;
		}
	} 
private:
	void realease()const 
	{
		((Myauto_ptr2<T>*)this)->_flag = false;
	}
	T* _mptr;
	bool _flag;//mutable bool _flag;  mutable 关键字保证了_flag就算是const对象中的成员，也可以被修改
};
4.实现二的问题

    根据管理权原则一，若旧智能指针有释放权，则新智能指针将释放权拿走，旧释放权false。那么如果这个新智能指针只是一个临时量，随着生存周期的到来也随之消失，那块被管理的内存岂不是莫名其妙就被释放了？

    问题一：智能指针作为函数的形参——传递实参的过程是初始化过程，可能发生释放权的转移，从而造成智能指针的提前释放
void test(Myauto_ptr2<int> rhs)
{
	cout<<*rhs<<endl;
}

int main()
{
	Myauto_ptr2<int> p(new int(10));
	Myauto_ptr2<int> q(new int(20));

	*p = 11;
	*q = 22;

	p = q;

	Myauto_ptr2<int> w = p;

	test(w);//在传参的过程中，w的释放权发生转移

	cout<<"w"<<*w<<endl;//打印一个随机值

	return 0;
}

二、scoped_ptr

    在auto_ptr中，因为设计的问题，导致在使用拷贝构造函数和 赋值运算符的可重载函数时，发生了访问 空指针、野指针的情况。为了规避这些情况，scoped_str在设计的时候就直接屏蔽了 拷贝构造函数 和 赋值运算符的可重载函数。scoped_ptr的原则——管理权唯一，释放权唯一。

1. 实现
#include <iostream>
using namespace std;

template <typename T>
class Myscoped_str
{
public:
	Myscoped_str(T* p):_mptr(p){}
	T& operator*()
	{
		return *_mptr;
	}
	T* operator->()
	{
		return _mptr;
	}
	~Myscoped_str()
	{
		delete _mptr;
		_mptr = NULL;
	}
private:
	Myscoped_str(const Myscoped_str<T>& rhs);
	Myscoped_str<T>& operator=(const Myscoped_str<T>& rhs);
	T* _mptr;
};
2. 问题

    scoped_ptr的原则也是“管理权唯一，释放权唯一”，因为屏蔽了 拷贝构造函数 和 赋值运算符的可重载函数，所以不可能通过这两种方式去 使得两个及以上的指针指向同一片内存，但是仍然避免不了人为的操作，即初始化两个scope_ptr指向同一片内存，当其中一个指针释放了该内存，另一个再想去修改内存的内容的话程序就会崩溃。

三、shared_ptr

    shared_ptr是基于“引用计数”实现的，多个shared_ptr可指向同一片内存，并且它们维护着共享的引用计数器——记录着指向同一片内存的shared_ptr对象的个数。当最后一个指向某一片内存的shared_ptr对象也销毁之后，会自动销毁掉该片内存。shared_ptr很好地解决了 多个智能指针指向一块内存块时, 析构时程序崩溃 的情况。shared_ptr的原则是——管理权不唯一，释放权不唯一。

1. 引用计数器
    我们只需要一个 引用计数器对象，这个对象中就存储了所有关于内存引用的信息，对于引用计数器的类设计就采用 单例模式。

class Refmanage
{
public:
	static Refmanage* GetSingle()
		//向外提供的 得到唯一引用计数器对象 的方法
	{
		return &_rm;
	}
public:
	void addref(void* ptr)
	{
		//判空
		if(ptr != NULL)
		{
			int index = Find(ptr);//在引用计数器中找一下改地址是否已有
			if(index < 0)//没找到
			{
				Node tmp(ptr,1);//新创结点
				_arr[_length++] = tmp;//插入引用计数器
			}
			else//找到该地址
			{
				_arr[index]._count++;
			}
			
		}
	}
	int getref(void* ptr)
	{
		//首先一定记得判空
		if(ptr == NULL)
		{
			return 0;
		}
		int index = Find(ptr);
		if(index < 0 )
		{
			return -1;
		}
		return _arr[index]._count;
	}
	void delref(void* ptr)//减少计数
	{
		if(ptr != NULL)
		{
			int index = Find(ptr);
			if(index < 0)
			{
				throw exception("addr is not exist");
			}
			else
			{
				if(_arr[index]._count != 0)
				{
					_arr[index]._count--;
				}
			}
		}
	}
private:
	Refmanage():_length(0)
	{}
	Refmanage(const Refmanage& rhs);
private:
	int Find(void* ptr)
	{
		for(int i=0; i<_length; i++)
		{
			if(_arr[i]._addr == ptr)
			{
				return i;//返回 addr的位置
			}
		}
		return -1;
	}
	class Node
	{
	public:
		Node(void* ptr=NULL, int num = 0):_addr(ptr),_count(num){}
		~Node(){memset(this,0,sizeof(Node));}
	public:
		void* _addr;//引用的内存地址
		int _count; //该内存的引用数
	};
	Node _arr[10];
	int _length;// 引用计数器的有效长度
	static Refmanage _rm; //唯一的引用计数器对象  
};
2. shared_ptr 实现
Refmanage Refmanage::_rm; //前置声明，否则 static Refmanage* rm 编译器不认识

template <typename T>
class Myshared_ptr
{
public:
	Myshared_ptr(T* ptr=NULL):_mptr(ptr)
	{
		AddRef();
	}
	Myshared_ptr(const Myshared_ptr<T>& rhs):_mptr(ptr)
	{
		AddRef();
	}
	Myshared_ptr& operator=(const Myshared_ptr<T>& rhs)
	{
		if(this != &rhs)
		{
			DelRef();
			this->~Myshared_ptr();
			_mptr = rhs._mptr;
			rhs.AddRef();
		}
		return *this;
	}
	~Myshared_ptr()
	{
		DelRef();
		if(GetRef() == 0)
		{
			delete _mptr;
		}
		_mptr = NULL;
	}
	T& operator*()
	{
		return *_mptr;
	}
	T* operator->()
	{
		return _mptr;
	}
private:
	void AddRef()
	{
		rm->addref(_mptr);
	}
	void DelRef()
	{
		rm->delref(_mptr);
	}
	int GetRef()
	{
		return rm->getref(_mptr);
	}
	T* _mptr;
	static Refmanage* rm; //指针
};

//静态成员变量类外初始化
template <typename T>
Refmanage* Myshared_ptr<T>::rm = Refmanage::GetSingle();
3. 问题
    虽然shared_ptr很好地解决了 “多个智能指针指向同一块内存时，析构时出错”的问题，可是同时也带来了新的问题。shared_ptr之间不能相互引用，否则管理的堆上内存块无法释放。
class B;
class A
{
public:
	A()
	{
		cout<<"A::A()"<<endl;
	}
	~A()
	{
		cout<<"A::~A()"<<endl;
	}
	Myshared_ptr<B> pb; //成员对象
};

class B
{
public:
	B()
	{
		cout<<"B::B()"<<endl;
	}
	~B()
	{
		cout<<"B::~B()"<<endl;
	}
	Myshared_ptr<A> pa; //成员对象
};

int main()
{
	Myshared_ptr<A> a(new A());
	Myshared_ptr<B> b(new B());

	a->pb = b;
	b->pa = a;

	return 0;
}
shared_ptr的相互引用造成了 内存泄露：

图解：


四、weak_ptr

    weak_ptr的出现就是为了 解决shared_ptr中“不能相互引用”的问题，因此weak_ptr需要和shared_ptr配合使用。weak_ptr是弱引用，而shared_ptr是一个强引用。
    强引用：只要有一个强引用指向该对象时，该对象就不会被释放。

    弱引用：弱引用只是当对象存在时的一个引用，对象不存在时弱引用能够检测出来，从而避免非法访问。弱引用并不像强引用那样可以进行内存管理(对引用计数没有影响)，它的特点就是可以检测到 对象已经不存在。

1. 实现
class Refmanage
{
public:
	static Refmanage* GetSingle()
		//向外提供的 得到唯一引用计数器对象 的方法
	{
		return &_rm;
	}
public:
	void addref(void* ptr)
	{
		//判空
		if(ptr != NULL)
		{
			int index = Find(ptr);//在引用计数器中找一下改地址是否已有
			if(index < 0)//没找到
			{
				Node tmp(ptr,1);//新创结点
				_arr[_length++] = tmp;//插入引用计数器
			}
			else//找到该地址
			{
				_arr[index]._count++;
			}
			
		}
	}
	int getref(void* ptr)
	{
		//首先一定记得判空
		if(ptr == NULL)
		{
			return 0;
		}
		int index = Find(ptr);
		if(index < 0 )
		{
			return -1;
		}
		return _arr[index]._count;
	}
	void delref(void* ptr)//减少计数
	{
		if(ptr != NULL)
		{
			int index = Find(ptr);
			if(index < 0)
			{
				throw exception("addr is not exist");
			}
			else
			{
				if(_arr[index]._count != 0)
				{
					_arr[index]._count--;
				}
			}
		}
	}

private:
	Refmanage():_length(0)
	{}
	Refmanage(const Refmanage& rhs);
private:
	int Find(void* ptr)
	{
		for(int i=0; i<_length; i++)
		{
			if(_arr[i]._addr == ptr)
			{
				return i;//返回 addr的位置
			}
		}
		return -1;
	}
	class Node
	{
	public:
		Node(void* ptr=NULL, int num = 0):_addr(ptr),_count(num){}
		~Node(){memset(this,0,sizeof(Node));}
	public:
		void* _addr;//引用的内存地址
		int _count; //该内存的引用数
	};
	Node _arr[10];
	int _length;// 引用计数器的有效长度
	static Refmanage _rm; //唯一的引用计数器对象  
};
Refmanage Refmanage::_rm;

template <typename T>
class Myshared_ptr
{
public:
	Myshared_ptr(T* ptr=NULL):_mptr(ptr)
	{
		AddRef();
	}
	Myshared_ptr(const Myshared_ptr<T>& rhs):_mptr(ptr)
	{
		AddRef();
	}
	Myshared_ptr& operator=(const Myshared_ptr<T>& rhs)
	{
		if(this != &rhs)
		{
			DelRef();
			this->~Myshared_ptr();
			_mptr = rhs._mptr;
			AddRef();
		}
		return *this;
	}
	~Myshared_ptr()
	{
		DelRef();
		if(GetRef() == 0)
		{
			delete _mptr;
		}
		_mptr = NULL;
	}
	T& operator*()
	{
		return *_mptr;
	}
	T* operator->()
	{
		return _mptr;
	}
	T* Getptr()const
	{
		return _mptr;
	}
private:
	void AddRef()
	{
		rm->addref(_mptr);
	}
	void DelRef()
	{
		rm->delref(_mptr);
	}
	int GetRef()
	{
		return rm->getref(_mptr);
	}
	T* _mptr;
	static Refmanage* rm;
};
//静态成员变量类外初始化
template <typename T>
Refmanage* Myshared_ptr<T>::rm = Refmanage::GetSingle();

template<typename T>
class Myweak_ptr
{
public:
	Myweak_ptr(T* ptr = NULL) :
		_mptr(ptr)
	{}
	
	Myweak_ptr(const Myweak_ptr<T>& rhs)
		:_mptr(rhs._mptr)
	{}
	Myweak_ptr<T>& operator=(const Myweak_ptr<T>& rhs)
	{
		if (this != &rhs)
		{
			_mptr = rhs._mptr;
		}
		return *this;
	}
	Myweak_ptr<T>& operator=(const Myshared_ptr<T>& rhs)
	{
		_mptr = rhs.Getptr();
		return *this;
	}
	~Myweak_ptr()
	{}
	T* operator->()
	{
		return _mptr;
	}
	T& operator*()
	{
		return *_mptr;
	}
private:
	T* _mptr;
};

class B;
class A
{
public:
	A()
	{
		cout<<"A::A()"<<endl;
	}
	~A()
	{
		cout<<"A::~A()"<<endl;
	}
	Myweak_ptr<B> pb;
};

class B
{
public:
	B()
	{
		cout<<"B::B()"<<endl;
	}
	~B()
	{
		cout<<"B::~B()"<<endl;
	}
	Myweak_ptr<A> pa;
};

int main()
{
	Myshared_ptr<A> a(new A());
	Myshared_ptr<B> b(new B());

	a->pb = b;
	b->pa = a;

	return 0;
}

上面代码的执行结果显示  没有内存泄露出现。

2. 问题
    虽然 weak_ptr解决了强引用shared_ptr带来的 “循环引用-->内存泄露”的问题，但是使用weak_ptr的前提是 清楚代码中会出现shared_ptr相互引用的情况，但是并不总是容易看出，而且运行期的互相引用也不总是能够察觉。

    

    
    


智能指针详解
08-20 1110
一、RALL机制RAII（Resource Acquisition Is Initialization）是一种利用对象生命周期来控制程序资源（如内存、文件句柄、网络连接、互斥量等等）的简单技术。 他的思想是资源分配即初始化，定义一个类来封装资源的的分配和释放，在构造函数完成资源的分配和初始化，在析构函数完成资源的清理，可以保证资源的正确释放和初始化RAII要求，资源的有效期与持有资源的对象的⽣命期严
详谈智能指针
Payshent的博客
06-29 1564
一、什么是智能指针 在讲智能指针之前我们必须先知道什么是智能指针，智能指针是一个类，是对普通指针的一个封装使得智能指针对象具有普通指针类型一样的操作。 智能指针是存储指向动态分配（堆）对象指针的类，用于生存期控制，能够确保自动正确的销毁动态分配的对象，防止内存泄漏。它的具体通用的技术就是实现引用计数。（这个下面会讲） 智能指针是将一个计数器与类指向的对象相关连，引用计数就是跟踪该类有多少个
智能指针（c++）
最新发布
2502_90360884的博客
07-14 1064
shared_ptr基于”引⽤计数”模型实现，多个shared_ptr可指向同⼀个动态对象，并 维护⼀个共享的引⽤计数器，记录了引⽤同⼀对象的shared_ptr实例的数量。当两个或多个对象通过 std::shared_ptr 相互引⽤，形成循环引⽤时，会导致这些对象的引 ⽤计数永远不会变为 0，从⽽造成内存泄漏。std::weak_ptr 是 C++ 标准库 头⽂件中提供的⼀种智能指针， 它是⼀种弱引⽤，⽤于配合 std::shared_ptr 使⽤，从某种特定情况中看起来，子类就是父类，父类能做的事，
智能指针 auto_ptr、scoped_ptr、shared_ptr、weak_ptr
weixin_30629653的博客
07-26 267
　　什么是RAII？ RAII是Resource Acquisition Is Initialization的简称，是C++语言的一种管理资源、避免泄漏的惯用法。 RAII又叫做资源分配即初始化，即：定义一个类来封装资源的分配和释放，在构造函数完成资源的分配和初始化，在析构函数完成资源的清理，可以保证资源的正确初始化和释放。 　　为什么要使用RAII？ 在计算机系统中，资源是...
五点讲述C++智能指针的点点滴滴
weixin_44542399的博客
01-18 262
（在学习C/C++或者想要学习C/C++可以加我们的学习交流QQ群：712263501群内有相关学习资料） 0、摘要 本文先讲了智能指针存在之前C++面临的窘境，并顺理成章地引出利用RAII技术封装普通指针从而诞生了智能指针，然后以示例代码的形式讲解了三种智能指针的基本用法。为了更好地理解引用计数形式实现的智能指针，本文提供了实现一个简单版本的智能指针的方法，并讨论了引用计数形式的缺点。最后，本文...
智能指针的原理和实现
eriol的思考空间
09-26 220
   当类中有指针成员时，一般有两种方式来管理指针成员：一是采用值型的方式管理，每个类对象都保留一份指针指向的对象的拷贝；另一种更优雅的方式是使用智能指针，从而实现指针指向的对象的共享。      智能指针(smart pointer)的一种通用实现技术是使用引用计数(reference count)。智能指针类将一个计数器与类指向的对象相关联，引用计数跟踪该类有多少个对象共享同一指针。...
浅谈智能指针auto_ptr/shared_ptr/unique_ptr
哒哒的博客
05-23 7344
一.智能指针1.引入我们通常使用类似new申请一块空间，交由一个指针指向，假如说最后忘记delete，将会造成内存泄露。而智能指针的出现，就是对这种问题的解决方式，智能指针类似指针，却可以用于管理动态分配的内存。本章所解说的是三种智能指针: (1)C++98提出,C++11摒弃的auto_ptr C++11新增的 (2)shared_ptr (3)unique_ptr 在
浅谈ObjectARX智能指针AcDbObjectPointer的用法
edata的博客
03-31 1631
前言 用ARX智能指针打开对象,可以不在乎是否close, 但同时也要注意这个变量的作用域(生命周期)问题, ARX智能指针,他的原理是利用类的析构造函数特性自动关闭对象. 这里的智能指针指的是AcDbObjectPointer这一类使用AcDbObjectPointerBase基类派生的类模板统称. 下面是打开示例. void testOpen() { ads_point pt; ads_name ent; if (RTNORM != acedEntSel(NULL,ent,pt)) {
浅谈智能水表的现在和未来
01-20
与传统水表一般只具有流量采集和机械指针显示用水量的功能相比，是很大的进步。智能智能水表除了可对用水量进行记录和电子显示外，还可以按照约定对用水量进行控制，并且自动完成阶梯水价的水费计算，同时可以进行...
电子测量中的浅谈智能水表的现在和未来
10-22
与传统水表一般只具有流量采集和机械指针显示用水量的功能相比，是很大的进步。智能智能水表除了可对用水量进行记录和电子显示外，还可以按照约定对用水量进行控制，并且自动完成阶梯水价的水费计算，同时可以进行...
C++中的auto_ptr智能指针的作用及使用方法详解
01-20
智能指针(auto_ptr) 这个名字听起来很酷是不是？其实auto_ptr 只是C++标准库提供的一个类模板，它与传统的new/delete控制内存相比有一定优势，但也有其局限。本文总结的8个问题足以涵盖auto_ptr的大部分内容。  auto_ptr是什么？ auto_ptr 是C++标准库提供的类模板，auto_ptr对象通过初始化指向由new创建的动态内存，它是这块内存的拥有者，一块内存不能同时被分给两个拥有者。当auto_ptr对象生命周期结束时，其析构函数会将auto_ptr对象拥有的动态内存自动释放。即使发生异常，通过异常的栈展开过程也能将动态内存释放。auto_ptr不支持
智能指针概念和使用
黄土塬
11-15 293
目录结构: 一 通过案例引入智能指针 二 智能指针的作用 三 设计辅助类实现智能指针作用 四 设计类模板实现智能指针作用 五 使用stl和boost提供的标准智能指针类模板处理问题 一 通过案例引入智能指针 有如下的程序: #include using namespace std; class exam { public: exam(int *p):ptr§{} exam(exam &o...
UE4 智能指针优缺点
Ez_coder的博客
10-28 846
为什么使用UE智能指针？ 1.std::shared_ptr并不是在所有平台都可以使用的。 2.使用虚幻指针可以和其他虚幻容器及类型无缝协作。 3.提供线程安全可以更好的获取性能等。 UE4智能指针库整体的优点 1.可以像操作常规C++指针那样来复制、解引用及共享指针。 2.当没有共享引用时资源自动销毁。 3.支持const 前置声明不完全类型、类型转换等。 4.包含了多线程安全进行访问”线程安全“版本。 UE4智能指针性能上的优势 1.所有操作所占时间都是固定的。 2.共享指针解引用速度和C++指针一样快
C++智能指针
居老师的博客
04-07 707
智能指针是一个RAII类模型，用于动态分配内存，其设计思想是将基本类型指针封装为（模板）类对象指针，并在离开作用域时调用析构函数，使用delete删除指针所指向的内存空间。 在C++中，动态内存的管理是用一对运算符完成的：new和delete，new:在动态内存中为对象分配一块空间并返回一个指向该对象的指针，delete：指向一个动态独享的指针，销毁对象，并释放与之关联的内存。 动态内存管理经常会出现两种问题：一种是忘记释放内存，会造成内存泄漏；一种是尚有指针引用内存的情况下就释放了它，就会产生引用
智能指针
ddddfang的专栏
04-02 298
对于拥有构造函数的对象而言 new ABC 与 new ABC() 效果等同,但对于内置类型而言,eg. new int 指向的int未初始化,而 new int()指向的int采用值初始化(0) 动态内存管理3个常见问题： 1.忘记 delete 2.使用以及释放的内存,释放内存后将其置为 nullptr 是个好习惯,防止野指针,但是保护有限,比如可能存在多个指针指向相同的内存 3.重复dele...
说说C++智能指针(1): 关于shared_ptr
Tom
07-20 760
shared_ptr是新的标准库的一个主要成员，作为一个非嵌入式的智能指针，其设计可谓已经是绞尽脑汁。当然，还有很多人对它提出了不满。没有完美的设计，只有合适的设计。1. shared_ptr最大的特点是接口的简单性与实现的灵活性。    对于shared_ptr,object的
C++中智能指针概念及模拟实现
w903414的博客
02-28 1093
什么是智能指针，提出智能指针的目的是什么，智能指针的各版本，及模拟实现。
浅谈shared_ptr
09-14
shared_ptr 是 C++11 中引入的智能指针，它可以用来管理动态分配的内存资源。与传统的裸指针相比，shared_ptr 具有自动释放资源的能力，可以有效地避免内存泄漏和悬空指针的问题。 shared_ptr 是基于引用计数机制...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值