完整教程：智能指针：告别内存泄漏的利器----《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); } )

作业部分