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

posted on 2022-03-01 23:34  七昂的技术之旅  阅读(137)  评论(0)  编辑  收藏  举报

导航