C++智能指针详解

简介: 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出来的对象或者是不同的类型的对象都可以由智能指针进行管理。

目录
相关文章
|
6天前
|
存储 安全 编译器
在 C++中,引用和指针的区别
在C++中,引用和指针都是用于间接访问对象的工具,但它们有显著区别。引用是对象的别名,必须在定义时初始化且不可重新绑定;指针是一个变量,可以指向不同对象,也可为空。引用更安全,指针更灵活。
|
25天前
|
存储 C++
c++的指针完整教程
本文提供了一个全面的C++指针教程,包括指针的声明与初始化、访问指针指向的值、指针运算、指针与函数的关系、动态内存分配,以及不同类型指针(如一级指针、二级指针、整型指针、字符指针、数组指针、函数指针、成员指针、void指针)的介绍,还提到了不同位数机器上指针大小的差异。
24 1
|
25天前
|
存储 编译器 C语言
C++入门2——类与对象1(类的定义和this指针)
C++入门2——类与对象1(类的定义和this指针)
22 2
|
27天前
|
存储 安全 编译器
【C++】C++特性揭秘:引用与内联函数 | auto关键字与for循环 | 指针空值(一)
【C++】C++特性揭秘:引用与内联函数 | auto关键字与for循环 | 指针空值
|
1月前
|
存储 C++ 索引
C++函数指针详解
【10月更文挑战第3天】本文介绍了C++中的函数指针概念、定义与应用。函数指针是一种指向函数的特殊指针,其类型取决于函数的返回值与参数类型。定义函数指针需指定返回类型和参数列表,如 `int (*funcPtr)(int, int);`。通过赋值函数名给指针,即可调用该函数,支持两种调用格式:`(*funcPtr)(参数)` 和 `funcPtr(参数)`。函数指针还可作为参数传递给其他函数,增强程序灵活性。此外,也可创建函数指针数组,存储多个函数指针。
|
2月前
|
编译器 C++
【C++核心】指针和引用案例详解
这篇文章详细讲解了C++中指针和引用的概念、使用场景和操作技巧,包括指针的定义、指针与数组、指针与函数的关系,以及引用的基本使用、注意事项和作为函数参数和返回值的用法。
33 3
|
27天前
|
存储 编译器 程序员
【C++】C++特性揭秘:引用与内联函数 | auto关键字与for循环 | 指针空值(二)
【C++】C++特性揭秘:引用与内联函数 | auto关键字与for循环 | 指针空值
|
2月前
|
C++
C++(十八)Smart Pointer 智能指针简介
智能指针是C++中用于管理动态分配内存的一种机制,通过自动释放不再使用的内存来防止内存泄漏。`auto_ptr`是早期的一种实现,但已被`shared_ptr`和`weak_ptr`取代。这些智能指针基于RAII(Resource Acquisition Is Initialization)原则,即资源获取即初始化。RAII确保对象在其生命周期结束时自动释放资源。通过重载`*`和`-&gt;`运算符,可以方便地访问和操作智能指针所指向的对象。
|
2月前
|
C++
C++(九)this指针
`this`指针是系统在创建对象时默认生成的,用于指向当前对象,便于使用。其特性包括:指向当前对象,适用于所有成员函数但不适用于初始化列表;作为隐含参数传递,不影响对象大小;类型为`ClassName* const`,指向不可变。`this`的作用在于避免参数与成员变量重名,并支持多重串联调用。例如,在`Stu`类中,通过`this-&gt;name`和`this-&gt;age`明确区分局部变量与成员变量,同时支持链式调用如`s.growUp().growUp()`。
|
3月前
|
存储 安全 C++
C++:指针引用普通变量适用场景
指针和引用都是C++提供的强大工具,它们在不同的场景下发挥着不可或缺的作用。了解两者的特点及适用场景,可以帮助开发者编写出更加高效、可读性更强的代码。在实际开发中,合理选择使用指针或引用是提高编程技巧的关键。
30 1