完整教程：智能指针：告别内存泄漏的利器----《Hello C++ Wrold!》(27)--(C/C++)

文章目录

• 前言
• 智能指针的作用
• 智能指针的实现和原理
• 库里面的智能指针
• • std::auto_ptr
  • • auto_ptr的模拟实现
  • std::unique_ptr
  • • unique_ptr的模拟实现
  • std::shared_ptr
  • • shared_ptr的模拟实现
    • shared_ptr的一个弊端
  • std::weak_ptr
  • • weak_ptr的模拟实现
  • 删除定制器
• 作业部分

前言

在 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); } )

作业部分