c++11 动态内存与智能指针详解

c++ 动态内存与智能指针详解

一、 动态内存

（一）程序对象的生存期

• 全局对象在程序启动时分配，在程序结束时销毁。

• 对于局部自动对象，当我们进入其定义所在的程序块时被创建，在离开块时销毁。

• 局部static对象在第一次使用前分配，在程序结束时销毁。

• C++还支持动态分配对象。动态分配的对象的生存期与它们在哪里创建是无关的，只有当显式地被释放时，这些对象才会销毁。

（二） 动态内存管理

在C++中，动态内存的管理是通过一对运算符来完成的：new，在动态内存中为对象分配空间并返回一个指向该对象的指针，我们可以选择对对象进行初始化；delete，接受一个动态对象的指针，销毁该对象，并释放与之关联的内存。

（三） RAII

1. 什么是RAII？

RAII（Resource Acquisition Is Initialization）是由c++之父Bjarne Stroustrup提出的，中文翻译为资源获取即初始化，他说：使用局部对象来管理资源的技术称为资源获取即初始化；这里的资源主要是指操作系统中有限的东西如内存、网络套接字等等，局部对象是指存储在栈的对象，它的生命周期是由操作系统来管理的，无需人工介入。

1. 如何实现RAII？

利用编译器自动创建、销毁局部对象的特点，可以实现RAII：

a.设计一个类封装资源

b.在构造函数中初始化（创建对象、加锁）

c.在析构函数中执行销毁操作 （销毁对象、解锁）

d.使用时声明一个该对象的类

1. 用途：通过类封装资源，实现动态内存的创建和回收，实现互斥锁的加锁与开锁。

二、RAII的应用——智能指针

为了更容易（同时也更安全）地使用动态内存，新的标准库提供了两种智能指针（smart pointer）类型来管理动态对象。智能指针的行为类似常规指针，**重要的区别是它负责自动释放所指向的对象**。

（一）智能指针shared_ptr和unique_ptr共有操作：

1. p->mem

   即(*p).mem

2. p.get()

   返回保存的指针

3. swap(p, q) 或p.swap(q)

   交换p、q中的指针

（二）shared_ptr类

shared_ptr<T>允许多个指针指向同一个对象； 在内部维护一个引用计数。shared_ptr类只有两个指针成员，一个指针是所管理的数据的地址；还有一个指针是控制块的地址，包括引用计数、weak_ptr计数、删除器、分配器。其中引用计数的存储是在堆上的。 因此一个shared_ptr对象的大小是raw_pointer大小的两倍。

      element_type*	   _M_ptr;         // Contained pointer.
      __shared_count<_Lp>  _M_refcount;    // Reference counter.

1. make_shared<T> p(q)

   p是q的拷贝，此操作递增q中的计数器。q中的指针必须能转换为T*。

2. make_shared<T>()

   允许传入的参数与T的某个构造函数匹配。

3. p.unique()

4. p.use_count()

5. p.reset() 或 p.reset(q)

• p.reset(); //释放p中内置的指针指向的空间
• p.reset(q); //将p中内置指针换为q，并且用d来释放p之前所指的空间

1. 拷贝和赋值

   • 拷贝：无论何时我们拷贝一个shared_ptr，计数器都会递增。例如，当用一个shared_ptr初始化另一个shared_ptr，或将它作为参数传递给一个函数以及作为函数的返回值时，它所关联的计数器就会递增。

   • 赋值：当我们给shared_ptr赋予一个新值或是shared_ptr被销毁（例如一个局部的shared_ptr离开其作用域时，计数器就会递减。

   auto r = make_shared<int>(42);
   r = q; //给r赋值，另其指向另一个地址
   //递增q所指向对象的引用计数
   //递减r原来所指对象的引用技术
   //r原来指向的对象已没有引用者，会自动释放内存。
   

2. 自动销毁所管理的对象：

   当指向一个对象的最后一个shared_ptr被销毁时，即引用计数为0时，shared_ptr类会自动销毁此对象。它是通过另一个特殊的成员函数——析构函数（destructor）完成销毁工作的。

3. 转移控制权

   sp2 = std::move(sp1)
   

（三）unique_ptr类

unique_ptr则“独占”所指向的对象。

template<
    class T,
    class Deleter = std::default_delete<T>
> class unique_ptr;
(1)	(since C++11)

template <
    class T,
    class Deleter
> class unique_ptr<T[], Deleter>;
(2)	(since C++11)

1. 不能拷贝和赋值，对应拷贝构造函数和赋值运算符函数已定义删除。

       // Disable copy from lvalue.
       unique_ptr(const unique_ptr&) = delete;
       unique_ptr& operator=(const unique_ptr&) = delete;
   

2. 可以用raw pointer进行reset。

   sp.reset(*TYPE)
   

3. 释放所有权 sp.release()

4. 转移控制权 std::move(sp)

   
   #include <iostream>
   #include <memory>
   using namespace std;
   
   int main(){
       unique_ptr<int> p1 = make_unique<int>(1);
       unique_ptr<int> p2 = make_unique<int>(2);
       p1.swap(p2); //交换指针
       cout<<*p1<<endl;
       cout<<*p2<<endl;
       int* a = new int(3);
       p1.reset(a);  //用*Type类型重置p1
       cout<<*p1<<endl;
       p1.release();  //释放所有权
       unique_ptr<int> p3 = std::move(p2); // 转移控制权
       cout<<*p3<<endl;
   
       return 0;
   }
   
   // 2
   // 1
   // 3
   // 1
   

（四）weak_ptr类

https://blog.csdn.net/Xiejingfa/article/details/50772571

1. 标准库还定义了一个名为weak_ptr的伴随类，它是一种弱引用，指向shared_ptr所管理的对象，而不影响所指对象的生命周期，也就是将一个weak_ptr绑定到一个shared_ptr不会改变shared_ptr的引用计数。不论是否有weak_ptr指向，一旦最后一个指向对象的shared_ptr被销毁，对象就会被释放。用于解决shard_ptr中可能存在的循环引用而导致内存泄露的问题。

2. weak_ptr对它所指向的shared_ptr所管理的对象没有所有权，若要读取引用对象，必须要转换成shared_ptr。

3. 如何判断weak_ptr指向对象是否存在呢？

   C++中提供了lock函数来实现该功能。如果对象存在，lock()函数返回一个指向共享对象的shared_ptr，否则返回一个空shared_ptr。

   shared_ptr<A> pa = wp.lock()

   #include <memory>
   #include <iostream>
   using namespace std;
   void Check(weak_ptr<int> & wp) {
       shared_ptr<int> sp = wp.lock(); // 转换为shared_ptr<int>
       if (sp != nullptr)
           cout << "still " << *sp << endl;
       else
           cout << "pointer is invalid." << endl;
   }
   int main() {
       shared_ptr<int> sp1(new int(22));
       shared_ptr<int> sp2 = sp1;
       weak_ptr<int> wp = sp1; // 指向shared_ptr<int>所指对象
       cout << *sp1 << endl;    // 22
       cout << *sp2 << endl;    // 22
       Check(wp);                  // still 22
       sp1.reset();
       cout << *sp2 << endl;    // 22
       Check(wp);                  // still 22
       sp2.reset();
       Check(wp);                  // pointer is invalid
   }
   
   

4. 一些内置方法

   https://en.cppreference.com/w/cpp/memory/weak_ptr

   Modifiers	Description
   reset()	releases the ownership of the managed object
   swap()	swaps the managed objects

   Obeservers	Description
   use_count()	returns the number of shared_ptr objects that manage the object
   expired()	checks whether the referenced object was already deleted
   lock()	creates a shared_ptr that manages the referenced object
   owner_before()	provides owner-based ordering of weak pointers

三、关于智能指针的更多问题

（1）自定义删除器 Deleter

实例见：

https://blog.csdn.net/caroline_wendy/article/details/16938707

"shared_ptr"的传递删除器(deleter)方式比较简单, 只需要在参数中添加具体的删除器函数名, 即可; 注意是单参数函数;

"unique_ptr"的删除器是函数模板(function template), 所以需要在模板类型传递删除器的类型(即函数指针(function pointer)), 再在参数中添加具体删除器;

（2）shared_ptr的线程安全问题

https://blog.csdn.net/www_dong/article/details/114418454

• shared_ptr引用计数的增减通过原子操作来实现，因此是线程安全的。
• shared_ptr指针所指向的资源被多个线程读写时，会存在线程安全的问题，不是线程安全的。

（3）智能指针SmartPointer与裸指针RawPointer效率对比问题

memory-and-performance-overhead-of-smart-pointer

how-much-is-the-overhead-of-smart-pointers-compared-to-normal-pointers-in-c

1. shared_ptr由于占据更多内存，且需要通过原子操作维护引用计数，因此效率是比较慢的。在不开启编译器优化的时候，是比new操作慢10倍，此时不应该使用make_shared、shared_ptr。开启优化后，也大概慢2-3倍。
2. unique_ptr、make_unique、带少许偏差的make_shared几乎和new、delete具有一样的性能。
3. unique_ptr自动管理内存资源，而几乎没有额外开销。因此效率和new\delete几乎一样。

（4）智能指针的应用场景

1. shared_ptr

• shared_ptr 内部有引用计数，在对象所有权需要共享的时候(share)用，shared_ptr 具有赋值拷贝的语义。

• 作为需要保存在容器里的对象，同时避免频繁创建引起性能上的开销。如果一个类的创建需要比较多的资源（例如比较大的的内存和拷贝），如果我们直接保存在容器里可能会在拷贝时产生比较大的性能损失，这个时候可以考虑使用shared_ptr进行资源共享，然后将shared_ptr保存于容器。

     vector<std::shared_ptr<Foo>> foos;
     // ...
     for(auto &foo : foos){
         process_func(*foo);
     }

C++ 三种智能指针的使用场景

原文链接： https://xie.infoq.cn/article/d7850479aa075a82126099de6

2. unique_ptr

独占对象的拥有权。C++14通过make_unique创建unique_ptr，是一种更加异常安全的做法。

  /// std::make_unique for single objects
  template<typename _Tp, typename... _Args>
    inline typename _MakeUniq<_Tp>::__single_object
    make_unique(_Args&&... __args)
    { return unique_ptr<_Tp>(new _Tp(std::forward<_Args>(__args)...)); }

  /// std::make_unique for arrays of unknown bound
  template<typename _Tp>
    inline typename _MakeUniq<_Tp>::__array
    make_unique(size_t __num)
    { return unique_ptr<_Tp>(new remove_extent_t<_Tp>[__num]()); }

  /// Disable std::make_unique for arrays of known bound
  template<typename _Tp, typename... _Args>
    inline typename _MakeUniq<_Tp>::__invalid_type
    make_unique(_Args&&...) = delete;

3. weak_ptr

• 打破shared_ptr循环引用导致的内存泄露，例如使用weak_ptr 保存二叉树的 parent 节点。

#include <memory>

struct node
{
   std::shared_ptr<node> left_child;
   std::shared_ptr<node> right_child;
   std::weak_ptr<node> parent;
   foo data;
};

• 缓存

• 观察者模式的订阅者

  • 观察者（Observer）模式的定义：指多个对象间存在一对多的依赖关系，当一个对象的状态发生改变时，所有依赖于它的对象都得到通知并被自动更新。这种模式有时又称作发布-订阅模式、模型-视图模式，它是对象行为型模式。

  观察者模式详解

  • 缺点：
    
    它的主要缺点是目标与观察者之间的依赖关系并没有完全解除，而且有可能出现循环引用。当观察者对象很多时，通知的发布会花费很多时间，影响程序的效率。

（5）enable_shared_from_this模板类

• 作用：用于在类对象的内部中获得一个指向当前对象的 shared_ptr 对象

C++11中enable_shared_from_this的用法解析

cppreference enable_shared_from_this

• 直接使用this不行吗？

假如this被push_back()到一个shared_ptr的vector，会通过this为该对象的内存块创建一个新的智能指针而生成新的控制块，则会可能出现未知错误。

Effective Modern C++:

std::enable_shared_from_this defines a member function that creates a std::shared_ptr to the current object, but it does it without duplicating control blocks. The member function is shared_from_this, and you use it in member functions whenever you want a std::shared_ptr that points to the same object as the this pointer.

• 使用方法：

继承enable_shared_from_this类；通过shared_from_this()方法返回

（6）智能指针模板中的类型可以是数组吗?

https://stackoverflow.com/questions/13061979/can-you-make-a-stdshared-ptr-manage-an-array-allocated-with-new-t