前言

在 C++ 编程中，动态内存管理始终是开发者面临的核心挑战之一。手动使用new分配内存、delete释放内存的模式，不仅需要开发者时刻关注内存生命周期，更可能因疏忽导致内存泄漏（忘记调用delete）、二次释放（重复调用delete），或是在异常抛出时因执行流跳转跳过delete语句等问题 —— 这些隐患轻则导致程序性能退化，重则引发崩溃或不可预期的运行错误，成为项目中难以排查的 “隐形 bug”。

为解决这一痛点，C++ 标准库引入了智能指针这一核心工具。它基于 “资源获取即初始化”（RAII）的设计思想，将动态内存资源封装为对象的成员，利用 C++ 对象自动调用析构函数的特性，实现内存的 “自动释放”，从根本上减少手动管理内存的负担与风险。

本文将系统梳理智能指针的核心作用、实现原理，并针对 C++ 标准库中不同类型的智能指针（auto_ptr、unique_ptr、shared_ptr、weak_ptr）展开详细解析：包括它们的设计逻辑、模拟实现代码、适用场景，以及如何规避shared_ptr循环引用等典型问题。同时，文中还将补充 “删除定制器” 等进阶用法，帮助开发者根据实际需求灵活应对复杂的内存管理场景，最终掌握高效、安全的 C++ 动态内存管理方案。

智能指针的作用

作用：如果正确使用了智能指针的话，就不用自己手动delete了

自己手动delete容易忽略的地方:在抛异常时容易跳过自己写的delete或者自己忘记delete了

智能指针的实现和原理

原理:资源交给对象管理，对象生命周期内，资源有效;对象生命周期到了，释放资源–用的是RAII思想

–在实现的时候要让这个对象的用法像指针一样哈

智能指针的实现:
template<class T>
class SmartPtr
{
public:
	SmartPtr(T* ptr)
		:_ptr(ptr)
	{}

	~SmartPtr()
	{
		delete _ptr;
	}

	T& operator*()
	{
		return *_ptr;
	}

	T* operator->()
	{
		return _ptr;
	}
private:
	T* _ptr;
};

用的话就eg:SmartPtr<string> sp(new string("renshen"));

但是这种智能指针有个问题:

eg:
     SmartPtr<string>sp1(new string("xxx"));
   SmartPtr<string>sp2(new string("yyy"));
sp1 = sp2;//这样的话sp2原来指向的内存就没人管理了，程序结束的时候都没被释放
//这里没被释放:sp2的析构函数已经不是对原来指向的内存作用了

库里面的智能指针

不需要拷贝的场景，一般使用unique_ptr

需要拷贝的场景，一般使用shared_ptr–但是要小心循环引用

std::auto_ptr

这个是C++98实现的 原理其实就是管理权的转移–eg:在拷贝，会把被拷贝对象的资源管理权转移给拷贝对象，被拷贝对象悬空

这个智能指针也是基于RAII思想搞出来的

这个智能指针有很大的弊端:如果管理权被转移了的话，之前那个指针就会变成空指针

–因此很多公司都是明令禁止使用的

auto_ptr的模拟实现

template<class T>
class auto_ptr
{
public:
	auto_ptr(T* ptr)
		:_ptr(ptr)
	{}

	~auto_ptr()
	{
		delete _ptr;
	}

	T& operator*()
	{
		return *_ptr;
	}

	T* operator->()
	{
		return _ptr;
	}

	auto_ptr(auto_ptr<T>& ap)
		:_ptr(ap._ptr)
	{
		ap._ptr = nullptr;
	}
//其实还有=号，->会把eg:sp1 = sp2的sp1原来的内存delete掉，然后管理权转移

private:
	T* _ptr;
};

使用eg:A是一个类
auto_ptr<A>ap1(new A(5));//new A(5)这可不是什么匿名对象

std::unique_ptr

unique_ptr,shared_ptr和weak_ptr是Boost库先实现的(底层和名字稍有不同)，后来C++11也支持这几个智能指针的使用了

unique_ptr的话就是直接让智能指针不能拷贝和赋值+管理权转移

–这个智能指针也是基于RAII思想实现的

unique_ptr的模拟实现

template<class T>
class unique_ptr
{
public:

	unique_ptr(T* ptr)
		:_ptr(ptr)
	{}

	~unique_ptr()
	{
		delete _ptr;
	}

	T& operator*()
	{
		return *_ptr;
	}

	T* operator->()
	{
		return _ptr;
	}


	unique_ptr(unique_ptr<T>& ap) = delete;
	unique_ptr<T>& operator=(unique_ptr<T>& ap) = delete;
//除了这种办法:还能private这个成员函数，并且只声明不实现
private:
	T* _ptr;
};

使用:unique_ptr<A>up1(new A(5));

引申:一般拷贝不让实现的话，赋值也不能实现–就像上面禁止就一起禁止了

std::shared_ptr

这个智能指针是最全面的–一般都是用的这个,然后有循环引用的时候搭配weak_ptr用

–也是RAII思想实现的

原理:通过引用计数的方式来实现多个shared_ptr对象之间共享资源

shared_ptr的模拟实现

	template<class T>
	class shared_ptr
	{
	public:

shared_ptr(T* ptr = nullptr)
	:_ptr(ptr)
	,_pcount(new int(1))
{}

		template<class D>
shared_ptr(T* ptr, D del)
	:_ptr(ptr)
	, _pcount(new int(1))
	, _del(del)
{}

		~shared_ptr()
		{
			if (--(*_pcount) == 0)//注意理解这里
			{
				_del(_ptr);
				delete _pcount;
			}
		}

		T& operator*()
		{
			return *_ptr;
		}

		T* operator->()
		{
			return _ptr;
		}

		shared_ptr(const shared_ptr<T>& sp)
			:_ptr(sp._ptr)
			,_pcount(sp._pcount)
		{
			++(*_pcount);
		}

		shared_ptr<T>& operator=(const shared_ptr<T>& sp)
		{
			if (_ptr == sp._ptr)
				return *this;//注意自己给自己赋值这个场景--一般都需要考虑

			if (--(*_pcount) == 0)
			{
				delete _ptr;
				delete _pcount;
			}

			_ptr = sp._ptr;
			_pcount = sp._pcount;
			++(*_pcount);

			return *this;//赋值的话一般return =前面的那个操作数
		}

T* get() const
{
	return _ptr;
}

	private:
		T* _ptr;
		int* _pcount;
//这里的计数 用静态的:static int count是不行的
   function<void(T*)> _del = [](T* ptr) {delete ptr; };//这个_del的类型很巧妙
	};

用法: shared_ptr<A>sp1(new A(1));
注意:shared_ptr<A>跟A可不是一个类型

引申:编译器对越界访问的检查一般不是很彻底的

shared_ptr的一个弊端

shared_ptr在遇到循环引用的时候也是会内存泄漏的

eg:循环引用的例子:
struct Node
{
	A _val;
	shared_ptr<Node> _next;
	shared_ptr<Node> _prev;
};
shared_ptr<Node> sp1(new Node);
shared_ptr<Node> sp2(new Node);
sp1->_next = sp2;
sp2->_prev = sp1;
这个场景sp1和sp2就出现了循环引用的场景    需要配合weak_ptr才能解决

解决这个问题就换成下面这个就行了
struct Node
{
	A _val;
	weak_ptr<Node> _next;
	weak_ptr<Node> _prev;
};
就是让shared_ptr的引用计数正常工作了

std::weak_ptr

weak_ptr这个智能指针不是RAII思想的，他的唯一作用就是解决shared_ptr的循环引用问题的

这个智能指针可以访问资源，但是不参与资源释放的解决

weak_ptr不能管理资源!!!

注意:weak_ptr库里面实现了让他可以和shared_ptr相互转换

weak_ptr的模拟实现

template<class T>
class weak_ptr
{
public:
	weak_ptr()
		:_ptr(nullptr)
	{}

	weak_ptr(const shared_ptr<T>& sp)
		:_ptr(sp.get())
	{}

	weak_ptr<T>& operator=(const shared_ptr<T>& sp)
	{
		_ptr = sp.get();
		return *this;
	}

	T& operator*()
	{
		return *_ptr;
	}

	T* operator->()
	{
		return _ptr;
	}
private:
	T* _ptr;
};
//weak_ptr其实也是可以转换成shared_ptr的，只是自己没有实现罢了

删除定制器

在智能指针使用过程中,可以会有new[]或者malloc出来的空间,这些空间用delete根本不行–此时就需要删除定制器了

库里面的话，是给unique_ptr和shared_ptr配备了删除定制器的

这里的话，自己模拟实现一下shared_ptr的删除定制器(在上面的模拟实现里面自己写了的)

使用方法:eg:
shared_ptr<A>sp2( (A*)malloc(sizeof(A)),[](A*ptr){free(ptr); } )

作业部分