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

Ne0inhk

23 Mar 2026 — 7 min read

文章目录

前言
智能指针的作用
智能指针的实现和原理
库里面的智能指针
作业部分

前言

在 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<classT>classSmartPtr{public:SmartPtr(T* ptr):_ptr(ptr){}~SmartPtr(){delete _ptr;} T&operator*(){return*_ptr;} T*operator->(){return _ptr;}private: T* _ptr;}; 用的话就eg:SmartPtr<string>sp(newstring("renshen"));

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

库里面的智能指针

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

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

std::auto_ptr

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

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

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

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

auto_ptr的模拟实现

template<classT>classauto_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(newA(5));//new A(5)这可不是什么匿名对象

std::unique_ptr

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

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

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

unique_ptr的模拟实现

template<classT>classunique_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(newA(5));

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

std::shared_ptr

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

–也是RAII思想实现的

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

shared_ptr的模拟实现

template<classT>classshared_ptr{public:shared_ptr(T* ptr =nullptr):_ptr(ptr),_pcount(newint(1)){}template<classD>shared_ptr(T* ptr, D del):_ptr(ptr),_pcount(newint(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(newA(1)); 注意:shared_ptr<A>跟A可不是一个类型

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

shared_ptr的一个弊端

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

std::weak_ptr

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

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

weak_ptr不能管理资源!!!

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

weak_ptr的模拟实现

template<classT>classweak_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的，只是自己没有实现罢了