C++动态内存

1. 序言

我们编写的程序中使用的对象都有生存期。全局对象在程序启动时分配，在程序结束时销毁。局部对象在我们进入其定义所在的程序块时被创建，在离开块时被销毁。static对象在第一次使用前分配，在程序结束时销毁。除了全局对象、局部对象和static对象外，C++还支持动态分配对象。动态分配的对象的生存期与它们在那里创建是无关的，只有当显式地被释放时，这些对象才会被销毁。
我们的程序到目前为止只使用过静态内存和栈内存。静态内存用来保存static对象、类static数据成员以及定义在函数之外的变量。栈内存用来保存定义在函数内的非static对象。分配在静态或栈内存中的对象由编译器自动创建和销毁。除了静态内存和栈内存，每个程序还拥有一个堆，程序用堆来储存动态分配的对象，即那些在程序运行时分配的对象。动态对象的生存周期由程序来控制，当动态对象不再使用时必须显式地销毁它们。

2. 动态内存和智能指针

在 C++ 中动态内存的管理是通过一对运算符来完成的：new在动态内存中为对象分配空间并返回一个指向该对象的指针，delete接受一个动态对象的指针，销毁该对象并释放相应的内存。
动态内存的使用很容易出问题，例如忘记释放内存会产生内存泄漏；在尚有指针引用内存的情况下释放会产生引用非法内存的指针。为了更容易的使用动态内存，新的标准库提供了两种智能指针类型来管理动态对象。
这两种智能指针的区别在于管理底层指针的方式：shared_ptr允许多个指针指向同一个对象；unique_ptr则独占所指向的对象。标准库还定义了一个名为weak_ptr的伴随类，它是一种弱引用，指向shared_ptr所管理的对象。这三种类型都定义在memory头文件中。

2.1 shared_ptr类

类似于 vector，智能指针也是模板，当我们创建一个智能指针时，必须提供额外的信息——指针可以指向的类型。

shared_ptr<string> p1;     // 指向string
shared_ptr<list<int>> p2;  // 指向int的list

智能指针的使用方式与普通指针类似，解引用一个智能指针返回它所指向的对象。如果在一个条件判断中使用智能指针，效果就是检测它是否为空：

// 如果p1存在检查它是否指向一个空string
if(p1 && p1->empty()) 
    *p1 = "hi";     // 如果条件成立，将"hi"赋值给p1

1.make_shared函数
最安全的分配和使用动态内存的方法是调用一个名为make_shared的标准库函数。此函数在动态内存中分配一个对象并初始化它，返回指向此对象的shared_ptr。与智能指针一样，make_shared 也定义在头文件memory中。当要用 make_shared 时，必须指定想要创建的对象的类型。定义方式与模板类相同，在函数名之后跟一个尖括号，在其中给出类型：

// 指向一个值为42的int的shared_ptr
shared_ptr<int>p3 = make_shared<int>42;  
// 指向一个值为"9999999999"的string
shared_ptr<string>p4 = make_shared<string>(10,'9');

当然也可以使用auto定义一个对象来保存 make_shared 的返回对象，如下所示：

auto p5 = make_shared<vector<string>>();  // p6指向一个动态分配的空vector容器

2.shared_ptr的拷贝与赋值
当进行拷贝或赋值操作时，每个 shared_ptr 都会记录有多个其他shared_ptr指向相同的对象：

auto p = make_shared<int>(42); // p指向的对象只有p一个引用者
auto q(p);    // p和q指向相同的对象，此对象有2个引用者

我们可以认为每个 shared_ptr 都有一个关联的计数器，通常称为引用计数。无论何时我们拷贝一个 shared_ptr，计数器都会递增。当一个 shared_ptr 的计数器变为 0，它就会自动释放自己所管理的对象。如下所示：

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

3.shared_ptr自动销毁所管理的对象
当指向一个对象的最后一个 shared_ptr 被销毁时，shared_ptr 类会自动销毁此对象。它是通过析构函数完成销毁工作的。shared_ptr 的析构函数会递减它所指向的都象的引用计数。如果引用次数变为 0，shared_ptr 的析构函数就会销毁对象，并释放它所占用的内存。当动态对象不再被使用时，shared_ptr 类会自动释放动态对象，这一特性使得动态内存的使用变得非常容易。例如有一个函数，它返回一个 shared_ptr，指向一个 Foo 类型的动态分配对象，对象是一个通过类型为 T 的参数进行初始化的：

// factory返回一个shared_ptr,指向一个动态分配的对象
shared_ptr<Foo> factory(T arg)
{
   
   // 恰当的处理arg
   // shared_ptr负责释放内存
   return make_shared<Foo> (arg);
}

由于 factory 返回一个 shared_ptr，所以我们可以确保它分配的对象会在恰当的时刻被释放。例如，下面的函数将 factory 返回的 shared_ptr 保存在局部变量中：

void use_factory(T arg)
{
   
   shared_ptr<Foo> p = factory(arg);
   // 使用p
}  // p离开了作用域，它指向的内存会被释放掉

由于 p 是局部变量，在函数结束时它将被销毁，会递减其引用计数并检查是否为 0，如果为 0，p 指向的这个对象也会销毁。
注意： 对于一块内存，shared_ptr 类保证只要还有任何 shared_ptr 对象引用它，它就不会被释放掉。
4.使用了动态生存期的资源的类
程序使用动态内出于以下三种原因之一：
1.程序不知道自己需要使用多少对象
2.程序不知道所需对象的准确类型
3.程序需要在多个对象之间共享数据
5.多个对象共享底层的数据
当我们拷贝一个 vector 时，原 vector 和副本 vector 中的元素是相互分离的：

vector<string> v1; // 空vector
{
    // 新作用域
  vector<string> v2 = {
   "a","an","the"};
  v1 = v2;   // 从v2拷贝元素到v1
} // v2被销毁，其中的元素也被销毁
  // v1有三个元素，是原来v2中元素的拷贝

由一个 vector 分配的元素只有当这个 vector 存在时才存在。当一个 vector 被销毁时，这个 vector 中的元素也都被销毁。
一般而言，如果两个对象共享底层的数据，当某个对象被销毁时，我们不能单方面的销毁底层数据，如下所示：

Blob<string> b1; // 空Blob, Blob为一个类
{
    // 新作用域
  Blob<string> b2 = {
   "a","an","the"};
  b1 = b2; // b1和b2共享相同的元素
} // b2被销毁了，但b2中的元素不能销毁
  // b1指向最初由b2创建的元素

6.定义StrBlob类
实现一个新的集合类型的最简单的方法是使用某个标准库容器来管理元素。采用这种方法，我们可以借助标准库类型来管理元素所使用的内存空间，在本例中我们将使用 vector 来保存元素。但是我们不能在一个 StrBlob 对象内直接保存 vector，因为一个对象的成员在对象销毁时也会被销毁，因此我们可