备案控制台
开发者社区 开发与运维 文章 正文

C++智能指针详解

2023-11-24 30
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
简介： C++智能指针详解

一、智能指针概念

智能指针是存储指向动态分配（堆）对象指针的类。除了能够在适当的时间自动删除指向的对象外，他们的工作机制很像C++的内置指针。智能指针在面对异常的时候格外有用，因为他们能够确保正确的销毁动态分配的对象。他们也可以用于跟踪被多用户共享的动态分配对象。


二、为什么需要智能指针

下面我们先分析一下下面这段程序有没有什么内存方面的问题？

int div()
{
  int a, b;
  cin >> a >> b;
  if (b == 0)
    throw invalid_argument("除0错误");
  return a / b;
}
void func()
{
  int* p1 = new int[10]; // 这里可能会抛异常，此时抛异常内存会分配失败，程序结束后不会造成内存泄漏。
  int* p2 = new int[10]; // 这里可能会抛异常，此时抛异常会导致p2以及后面的内存分配失败，退出程序后，
                         //由于p1已经成功申请内存，但是C++没有内存回收机制，因此会造成内存泄漏。
  int* p3 = new int[10]; // 这里可能会抛异常
  try
  {
    div();
  }
  catch (...)
  {
    delete[] p1;
    delete[] p2;
    delete[] p3;
    throw;
  }
  delete[] p1;
  delete[] p2;
  delete[] p3;
}
int main()
{
  try
  {
    func();
  }
  catch (const exception& e)
  {
    cout << e.what() << endl;
    // ...
  }
  return 0;
}

关于内存泄漏见文章【C++ 内存管理】

三、智能指针设计原理剖析

RAII思想

RAII（Resource Acquisition Is Initialization），也称为 “资源获取就是初始化” ，是一种利用对象生命周期来控制程序资源（如内存、文件句柄、网络连接、互斥量等等）的简单技术。RAII是C++语言的一种管理资源、避免泄漏的惯用法。C++标准保证任何情况下，已构造的对象最终会销毁，即它的析构函数最终会被调用。简单的说，RAII 的做法是使用一个对象，在其构造时获取资源，在对象生命期控制对资源的访问使之始终保持有效，最后在对象析构的时候释放资源。这种做法有两大好处：

  • 不需要显式地释放资源。
  • 采用这种方式，对象所需的资源在其生命期内始终保持有效

利用RAII思想设计的SmartPtr类

template<class T>
class SmartPtr {
public:
  SmartPtr(T* ptr = nullptr)
    : _ptr(ptr)
  {}
  ~SmartPtr()
  {
    if (_ptr)
      delete _ptr;
  }
private:
  T* _ptr;
};
int div()
{
  int a, b;
  cin >> a >> b;
  if (b == 0)
    throw invalid_argument("除0错误");
  return a / b;
}
void Func()
{
  SmartPtr<int> sp1(new int);
  SmartPtr<int> sp2(new int);
  cout << div() << endl;
}
int main()
{
  try {
    Func();
  }
  catch (const exception& e)
  {
    cout << e.what() << endl;
  }
  return 0;
}

利用RAII的思想，将变量的资源交给一个对象管理，在对象的生命周期结束之时自动释放资源，巧妙地解决了内存泄漏的问题。

但是上述的SmartPtr还不能将其称为智能指针，因为它还不具有指针的行为。指针可以解引用，也可以通过->去访问所指空间中的内容，因此：AutoPtr模板类中还得需要将 * 、-> 重载下，才可让其像指针一样去使用。

template <class T>
class SmartPtr
{
public:
  // RAII思想
  SmartPtr(T* ptr)
    :_ptr(ptr)
  {}
  ~SmartPtr()
  {
    //delete[] _ptr;
    delete _ptr;
    _ptr = nullptr;
  }
  // 像指针一样
  T& operator*()
  {
    return *_ptr;
  }
  T* operator->()
  {
    return _ptr;
  }
  T* Get()
  {
    return _ptr;
  }
private:
  T* _ptr;
};
struct Date
{
  int _year;
  int _month;
  int _day;
  Date(int year = 1, int month = 1, int day = 1)
  {
  }
};
int main()
{
  SmartPtr<int> sp1(new int);
  *sp1 = 10;
  cout << *sp1 << endl;
  SmartPtr<Date> sparray(new Date);
  // 需要注意的是这里应该是sparray.operator->()->_year = 2018;
  // 本来应该是sparray->->_year这里语法上为了可读性，省略了一个->
  sparray->_year = 2018;
  sparray->_month = 1;
  sparray->_day = 1;
}


总结一下智能指针的原理：

  1. RAII特性
  2. 重载operator*和opertaor->，具有像指针一样的行为。

四、C++标准库中的智能指针

1. std::auto_ptr

std::auto_ptr文档

C++98版本的库中就提供了auto_ptr的智能指针。下面演示的auto_ptr的使用及问题。

int main()
{
  std::auto_ptr<int> sp1(new int);
  std::auto_ptr<int> sp2(sp1); // 管理权转移
  // sp1悬空
  *sp2 = 10;
  cout << *sp2 << endl;
  cout << *sp1 << endl;
  return 0;
}

当sp2利用sp1进行拷贝构造时，sp1便被置空了，auto_ptr是一个失败设计，很多公司明确要求不能使用auto_ptr。

auto_ptr的实现原理：管理权转移的思想，下面简化模拟实现了一份bit::auto_ptr来了解它的原理。

namespace lhf
{
  template<class T>
  class auto_ptr
  {
  public:
    auto_ptr(T* ptr)
      :_ptr(ptr)
    {}
    auto_ptr(auto_ptr<T>& p)
      :_ptr(p._ptr)
    {
      p._ptr = nullptr; //管理权转移
    }
    auto_ptr<T>& operator=(auto_ptr<T>& p)
    {
      if (this != &p)
      {
        if (_ptr)
        {
          delete _ptr;
        }
        //资源转移到当前对象
        _ptr = p._ptr;
        p._ptr = nullptr;
      }
      return *this;
    }
    ~auto_ptr()
    {
      if (_ptr)
      {
        //cout << "delete" << endl;
        delete _ptr;
      }
    }
    T& operator*()
    {
      return *_ptr;
    }
    T* operator->()
    {
      return _ptr;
    }
  private:
    T* _ptr;
  };
}


2. std::unique_ptr

unique_ptr是C++11提供的。C++11库才更新了智能指针的实现，在C++11出来之前，第三方库boost已经搞好了更好用的scoped_ptr、shared_ptr、weak_ptr等智能指针，C++11将boost库中的智能指针的精华部分吸收了过来，实现了官方库的unique_ptr、shared_ptr、weak_ptr等智能指针。

unique_ptr文档

unique_ptr的实现原理：简单粗暴的防拷贝。下面简化模拟实现了一份unique_ptr来了解它的原理。

namespace lhf
{
  template<class T>
  class unique_ptr
  {
  public:
    unique_ptr(T* ptr)
      :_ptr(ptr)
    {}
    ~unique_ptr()
    {
      if (_ptr)
      {
        delete _ptr;
      }
    }
    T& operator*()
    {
      return *_ptr;
    }
    T* operator->()
    {
      return _ptr;
    }
    unique_ptr(const unique_ptr<T>& p) = delete;
    unique_ptr<T>& operator=(const unique_ptr<T>& p) = delete;
  private:
    T* _ptr;
  };
}


int main()
{
  lhf::unique_ptr<int> sp1(new int);
  lhf::unique_ptr<int> sp2(sp1);
  std::unique_ptr<int> sp1(new int);
  std::unique_ptr<int> sp2(sp1);
 return 0;
}

3. std::shared_ptr

std::shared_ptr文档


shared_ptr的原理：是通过引用计数的方式来实现多个shared_ptr对象之间共享资源。引用计数支持多个拷贝管理同一个资源，最后一个析构对象释放资源。


  1. shared_ptr在其内部，给每个资源都维护了着一份计数，用来记录该份资源被几个对象共享。
  2. 在对象被销毁时(也就是析构函数调用)，就说明自己不使用该资源了，对象的引用计数减一。
  3. 如果引用计数是0，就说明自己是最后一个使用该资源的对象，必须释放该资源；
  4. 如果不是0，就说明除了自己还有其他对象在使用该份资源，不能释放该资源，否则其他对象就成野指针了。

模拟实现shared_ptr的代码

namespace lhf
{
  template<class T>
  class shared_ptr
  {
  private:
    void release()
    {
      if (--(*_pCount) == 0 && _ptr)
      {
        cout << "delete" << _ptr << endl;
        delete _ptr;
        _ptr = nullptr;
        delete _pCount;
        _pCount = nullptr;
      }
    }
  public:
    shared_ptr(T* ptr)
      :_ptr(ptr)
      ,_pCount(new int(1))
    {}
    shared_ptr(const shared_ptr<T>& p)
      :_ptr(p._ptr)
      , _pCount(p._pCount)
    {
      ++(* _pCount);
    }
    shared_ptr<T>& operator=(const shared_ptr<T>& p)
    {
      if (_ptr != p._ptr)
      {
        this->release();
        _ptr = p._ptr;
        _pCount = p._pCount;
        ++(*_pCount);
      }
      return *this;
    }
    ~shared_ptr()
    {
      this->release();
    }
    T& operator*()
    {
      return *_ptr;
    }
    T* operator->()
    {
      return _ptr;
    }
  private:
    T* _ptr;
    int* _pCount;
  };
}
int main()
{
   lhf::shared_ptr<int> sp1(new int);
   lhf::shared_ptr<int> sp2(sp1);
   lhf::shared_ptr<int> sp3(sp1);
   lhf::shared_ptr<int> sp4(new int);
   lhf::shared_ptr<int> sp5(sp4);
   //sp1 = sp1;
   //sp1 = sp2;
   sp1 = sp4;
   sp2 = sp4;
   sp3 = sp4;
   *sp1 = 2;
   *sp2 = 3;
 return 0;
}

4. std::shared_ptr的循环引用

案例如下：

struct ListNode
{
  int _data;
  shared_ptr<ListNode> _prev;
  shared_ptr<ListNode> _next;
  ~ListNode() 
  {
    cout << "~ListNode()" << endl;
  }
};
int main()
{
  shared_ptr<ListNode> node1(new ListNode);
  shared_ptr<ListNode> node2(new ListNode);
  cout << node1.use_count() << endl;
  cout << node2.use_count() << endl;
  node1->_next = node2;
  node2->_prev = node1;
  cout << node1.use_count() << endl;
  cout << node2.use_count() << endl;
  return 0;
}

循环引用分析：


  1. node1和node2两个智能指针对象指向两个节点，引用计数变成1，我们不需要手动delete。
  2. node1的_next指向node2，node2的_prev指向node1，引用计数变成2。
  3. node1和node2析构，引用计数减到1，但是_next还指向下一个节点。但是_prev还指向上一个节点。
  4. 也就是说_next析构了，node2就释放了。
  5. 也就是说_prev析构了，node1就释放了。
  6. 但是_next属于node的成员，node1释放了，_next才会析构，而node1由_prev管理，_prev属于node2成员，所以这就叫循环引用，谁也不会释放。

解决方法：在引用计数的场景下，把节点中的_prev和_next改成weak_ptr。原理就是，node1->_next = node2;和node2->_prev = node1，时weak_ptr的_next和 _prev不会增加node1和node2的引用计数。

5. std::weak_ptr

std::weak_ptr 要与 std::shared_ptr 一起使用。 一个 std::weak_ptr 对象看做是 std::shared_ptr 对象管理的资源的观察者，它不影响共享资源的生命周期。

  1. 如果需要使用 weak_ptr 正在观察的资源，可以将 weak_ptr 提升为 shared_ptr。
  2. 当 shared_ptr 管理的资源被释放时，weak_ptr 会自动变成 nullptr。

weak_ptr的模拟实现

namespace lhf
{
  // 不参与指向资源的释放管理
  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 lhf::shared_ptr<T>& p)
    {
      _ptr = p._ptr;
      return *this;
    }
    // 像指针一样
    T& operator*()
    {
      return *_ptr;
    }
    T* operator->()
    {
      return _ptr;
    }
  public:
    T* _ptr;
  };
}
struct ListNode
{
  /*ListNode* _next = nullptr;
  ListNode* _prev = nullptr;*/
  std::weak_ptr<ListNode> _next;
  std::weak_ptr<ListNode> _prev;
  int _val = 0;
  ~ListNode()
  {
    cout << "~ListNode()" << endl;
  }
};
int main()
{
  std::shared_ptr<ListNode> node1(new ListNode);
  std::shared_ptr<ListNode> node2(new ListNode);
  cout << node1.use_count() << endl;
  cout << node2.use_count() << endl;
  node1->_next = node2;
  node2->_prev = node1;
  cout << node1.use_count() << endl;
  cout << node2.use_count() << endl;
  return 0;
}

删除器：

如果不是new出来的对象如何通过智能指针管理呢？其实shared_ptr设计了一个删除器来解决这个问题。

// 仿函数的删除器
template<class T>
struct FreeFunc
{
  void operator()(T* ptr)
  {
    cout << "free:" << ptr << endl;
    free(ptr);
  }
};
template<class T>
struct DeleteArrayFunc
{
  void operator()(T* ptr)
  {
    cout << "delete[]" << ptr << endl;
    delete[] ptr;
  }
};
int main()
{
  FreeFunc<int> freeFunc;
  std::shared_ptr<int> sp1((int*)malloc(4), freeFunc);
  DeleteArrayFunc<int> deleteArrayFunc;
  std::shared_ptr<int> sp2((int*)malloc(4), deleteArrayFunc); 
  std::shared_ptr<A> sp4(new A[10], [](A* p){delete[] p; });
  std::shared_ptr<FILE> sp5(fopen("test.txt", "w"), [](FILE* p){fclose(p); });
  return 0;
}

由此可见，利用删除器就可以使不是new出来的对象或者是不同的类型的对象都可以由智能指针进行管理。

文章标签：
C++
存储
关键词：
C++指针
C++智能指针
求知.
目录
相关文章
孤影过客
|
14天前
|
存储 安全 C++
C++中的引用和指针：区别与应用
引用和指针在C++中都有其独特的优势和应用场景。引用更适合简洁、安全的代码，而指针提供了更大的灵活性和动态内存管理的能力。在实际编程中，根据需求选择适当的类型，能够编写出高效、可维护的代码。理解并正确使用这两种类型，是掌握C++编程的关键一步。
孤影过客
19 1
奔跑的数据
|
14天前
|
数据采集 存储 编译器
this指针如何使C++成员指针可调用
本文介绍了C++中的this指针，它是一个隐藏的指针，用于在成员函数中访问对象实例的成员。文章通过代码示例阐述了this指针的工作原理，以及如何使用指向成员变量和成员函数的指针。此外，还提供了一个多线程爬虫示例，展示this指针如何使成员指针在对象实例上调用，同时利用代理IP和多线程提升爬取效率。
奔跑的数据
23 3
this指针如何使C++成员指针可调用
枫叶丹4
|
1天前
|
存储 安全 编译器
【C++航海王：追寻罗杰的编程之路】引用、内联、auto关键字、基于范围的for、指针空值nullptr
【C++航海王：追寻罗杰的编程之路】引用、内联、auto关键字、基于范围的for、指针空值nullptr
枫叶丹4
11 5
游客n5wu27bgadceq
|
2天前
|
存储 Java C#
C++语言模板类对原生指针的封装与模拟
C++｜智能指针的智能性和指针性：模板类对原生指针的封装与模拟
游客n5wu27bgadceq
8 3
长梦
|
2天前
|
设计模式 C++ 开发者
C++一分钟之-智能指针：unique_ptr与shared_ptr
【6月更文挑战第24天】C++智能指针`unique_ptr`和`shared_ptr`管理内存，防止泄漏。`unique_ptr`独占资源，离开作用域自动释放；`shared_ptr`通过引用计数共享所有权，最后一个副本销毁时释放资源。常见问题包括`unique_ptr`复制、`shared_ptr`循环引用和裸指针转换。避免这些问题需使用移动语义、`weak_ptr`和明智转换裸指针。示例展示了如何使用它们管理资源。正确使用能提升代码安全性和效率。
长梦
13 2
长梦
|
7天前
|
存储 算法 安全
C++一分钟之-数组与指针基础
【6月更文挑战第19天】在C++中，数组和指针是核心概念，数组是连续内存存储相同类型的数据，而指针是存储内存地址的变量。数组名等同于指向其首元素的常量指针。常见问题包括数组越界、尝试改变固定大小数组、不正确的指针算术以及忘记释放动态内存。使用动态分配和智能指针可避免这些问题。示例代码展示了安全访问和管理内存的方法，强调了实践的重要性。
长梦
24 3
游客zmvoaaeeaml62
|
12天前
|
编译器 Linux C++
C++智能指针
**C++智能指针是RAII技术的体现，用于自动管理动态内存，防止内存泄漏。主要有三种类型：已废弃的std::auto_ptr、不可复制的std::unique_ptr和可共享的std::shared_ptr。std::unique_ptr通过禁止拷贝和赋值确保唯一所有权，而std::shared_ptr使用引用计数来协调多个指针对同一资源的共享。在C++17中，std::auto_ptr因设计缺陷被移除。**
游客zmvoaaeeaml62
11 1
筱姌
|
19天前
|
存储 编译器 C++
C++中的指针
C++中的指针
筱姌
11 1
Srlua
|
21天前
|
存储 安全 编译器
C++进阶之路：何为引用、内联函数、auto与指针空值nullptr关键字
C++进阶之路：何为引用、内联函数、auto与指针空值nullptr关键字
Srlua
13 2
小王老师呀
|
24天前
|
C++ 存储 Java
C++ 引用和指针：内存地址、创建方法及应用解析
'markdown'C++ 中的引用是现有变量的别名，用 `&` 创建。例如：`string &meal = food;`。指针通过 `&` 获取变量内存地址，用 `*` 创建。指针变量存储地址，如 `string *ptr = &food;`。引用不可为空且不可变，指针可为空且可变，适用于动态内存和复杂数据结构。两者在函数参数传递和效率提升方面各有优势。 ```
小王老师呀
19 3

热门文章

最新文章

  • 1
    【C 言专栏】C 语言指针的深度解析
  • 2
    【C++】一文深入浅出带你参透库中的几种 [ 智能指针 ]及其背后实现原理（代码＆图示）
  • 3
    【Go语言专栏】Go语言中的指针与内存管理
  • 4
    C语言中的函数指针和回调函数
  • 5
    纯C++实现的HTTP请求封装（POST/GET）
  • 6
    C++模板初阶
  • 7
    Facebook 的 C++ 11 组件库 Folly Futures
  • 8
    读书笔记 effective c++ Item 46 如果想进行类型转换，在模板内部定义非成员函数
  • 9
    VC++之IP控件初始化问题
  • 10
    《C++语言基础》程序阅读——构造函数和析构函数
  • 1
    快慢指针该如何操作？本文带你认识快慢指针常见的三种用法及在链表中的实战
    33
  • 2
    c语言函数指针和指针函数的区别，以及回调函数的使用。
    19
  • 3
    项目中常见NPE空指针异常
    23
  • 4
    LeetCode刷题--- 61. 旋转链表（快慢指针+闭合为环）
    27
  • 5
    LeetCode刷题--- 138. 复制带随机指针的链表（哈希表+迭代）
    39
  • 6
    LeetCode刷题---21.合并两个有序链表（双指针）
    37
  • 7
    LeetCode刷题---链表经典问题（双指针）
    59
  • 8
    LeetCode刷题---19. 删除链表的倒数第 N 个结点（双指针-快慢指针）
    36
  • 9
    LeetCode刷题---160. 相交链表（双指针-对撞指针）
    29
  • 10
    LeetCode刷题---142. 环形链表 II（双指针-快慢指针）
    28

    • 相关课程

    更多
  • C++ 入门教程开发文档

    • 相关电子书

    更多
  • 使用C++11开发PHP7扩展
  • GPON Class C++ SFP O;T Transce
  • GPON Class C++ SFP OLT Transce
    • 下一篇
    部署LAMP环境（Alibaba Cloud Linux 3）