目录结构：

静态内存用来保存局部static对象、类static数据成员以及定义在任何函数之外的变量。栈内存用来保存定义在函数内的非static对象。分配在静态和栈内存中的对象由编译器自动创建和销毁。对于栈对象，仅在其定义的程序块运行时才存在；static对象在使用之前分配。在程序结束时销毁。

除了静态内存和栈内存，每个程序还拥有一个内存池。这部分内存被称为*空间（free store）或堆（heap）。程序用堆来存储动态分配（dynamically allocate）的对象，也就是那些在程序运行时分配的对象。动态内存的生存期由程序来控制，也就是说，当动态内存不再使用时，我们的代码必须显式地销毁它们。

1 动态内存和智能指针

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

动态内存的使用非常容器出现问题，因为确保在正确的时间释放内存是极其困难的。为了更好的管理动态内存，C++标准库在<memory>模块中提供了大量的智能指针类型，这里笔者就介绍几种较常见的：shared_ptr允许多个指针指向同一个对象，unqiue_ptr则“独占”所指向的对象。标准库还定义一个名为weak_ptr的伴随类，它是一种弱引用，指向shared_ptr所管理的对象。

1.1 使用shared_ptr管理内存

shared_ptr是一个智能指针类，它可以和其他的shared_ptr共享同一个动态内存的所有权。出现如下两种情况的话，动态内存会被自动释放：
a.最后一个保留动态内存的shared_ptr对象被销毁。
b.最后一个保留动态内存的shared_ptr对象重新保存另一个动态内存（通过=或reset()）

我们可以这样认为，每个shared_ptr都有一个关联的计数器，通常称为引用计数（reference count）。无论何时我们拷贝一个shared_ptr，计数器都会增加。例如，当用一个shared_ptr初始化另一个shared_ptr，或将它作为参数传递给一个函数以及作为函数的返回值时，它所关联的计数器就会递增。我我们给shared_ptr赋予一个新值或是shared_ptr被销毁（一个局部的shared_ptr离开作用域）时，计数器就会递减。

一旦一个shared_ptr的计数器变为0，它就会自动释放自己所管理的对象。

在使用shared_ptr时，我们无需关心内存的释放问题。程序会自动帮助我们在合适的时机释放内存。因此推荐在程序中使用shared_ptr来管理动态内存。

创建shared_ptr对象既可以通过它的构造方法，也可以通过make_shared方法。

#include <iostream> /*cout*/

#include <memory> /*shared_ptr,make_shared*/

#include <string> /*string*/

using namespace std;

int main(int argc,char* argv[]){

    shared_ptr<string> sp1 = make_shared<string>("hello");//通过make_shared创建

    // {} 块代码

    {

        shared_ptr<string> sp2; //shared_ptr的默认构造

        sp2 = sp1;//将sp1复制给sp2，sp1和sp2指向相同的动态内存

    }//退出块，sp2对象被销毁。sp2指向的动态内存不会被销毁(因为指向该内存的还有sp1，所以程序不会自动该动态内存)

    //现在只有sp1对象指向该动态内存了

    cout << *sp1 << endl;//打印sp1中的动态管理的值

return ;//退出方法，离开sp1对象作用域，sp1对象被销毁。由于sp1对象是最后一个指向动态内存的shared_ptr对象，所以该动态内存被释放。

}

shared_ptr（以及其他的智能指针）除了可以管理new分配的资源，也可以管理不是new分配的资源，这时候记得传递给它一个删除器（因为默认的删除器，是针对new分配资源的删除器，也就是调用delete），例如下面一个网络库代码：

struct destination;     //表示连接的目标信息

struct connection;      //使用连接所需信息

connection connect(destination*);    //打开连接

void disconnect(connection);    //关闭给定连接

void end_connection(connection *p){

    diconnect(*p);

}

void f(destination &d){

    //未使用shared_ptr

    /*

    //获得一个连接；记住使用完后要关闭它

    connection c = connect(&d);

    //使用连接

    //如果我们在f退出之前，忘记调用disconnect，就无法关闭c了。

    */

    //使用shared_ptr

    connection c = connect(&d);

    shared_ptr<connection> p(&c,end_connection);//一定要传入自定义的删除器，也可以用lambda表达式

    //使用连接

    //当f退出时（即使是由于异常而退出），connection会被正确关闭

}

1.2 使用new直接管理内存

C++语言定义两个运算符来分配和释放动态内存。运算符new分配内存，delete释放new分配的内存。

在堆中分配的内存是无名的，因此new无法为其分配的对象命令，而是返回一个指向该对象的指针：

int *pi = new int;//pi指向一个动态的、未初始化的无名对象

我们可以采用直接构造的方式来初始化一个动态分配对象，我们可以使用传统的的构造方式（使用圆括号），我们还可以使用列表初始化的方法（花括号）：

int *p = new int; //p指向一个未初始化的int

int *p2 = new int(); //p2指向的对象的值为0

int *pi = new int()；   //pi指向的对象的值为1024

string *ps = new string(,"");   //*ps为999999999

//vector有10个元素，依次从0到9

vector<int> *pv = new vector<int>{,,,,,,,,,}

如果我们提供了一个括号包围的初始化器，就可以使用auto从此初始化器来推断我们想要分配的对象的类型。但是，由于编译器要使用初始化器的类型来推断我们想要的创建的类型，只有当括号中有单一初始化器时才可用auto

auto p1 = new auto(obj);  //p指向一个与obj相同类型的对象

auto p2 = new auto{a,b,c};  //错误，括号中只能有单一初始化器

p1的类型是指针，指向从obj推断出来的类型。若obj是int，那么p1就是int*类型，若obj是string,那么p1就是string*类型。

动态分配的const对象

用new分配const对象是合法的：

//分配并初始化一个const int

const int* pci = new const int();

//分配并默认初始化一个const的空string

const string* pcs = new const string();

和其它const一样，一个动态的const对象必需要初始化。对于一个定义了默认构造函数的类类型，其const对象可以隐式初始化，而其他的类型必须显示初始化。由于分配的对象是const的，new返回的指针是一个指向const的指针。

内存耗尽

虽然现代计算机通常都具备大容量内存，但是*空间被耗尽的情况还是有可能发生。一旦一个程序用光了它所有的内存，new表达式就会失败。默认情况下，如果new不能分配所要求的空间，它就会抛出一个类型为bad_alloc的异常。我们可以改变new的使用方式来阻止它：

//如果分配失败，new返回一个空指针

int *p1 = new int; //如果分配失败，抛出std::bad_alloc的异常。

int *p2 = new (nothrow) int; //如果分配失败，new返回一个空指针

释放动态内存

为了防止内存耗尽，在动态内存使用完毕后，必须将其归还给系统。我们通过delete表达式(delete expression)来将动态内存归还给系统。delete表达式接受一个指针，指向我们想要释放的对象：

delete  p;//p必须指向一个动态内存分配的对象或是一个空指针

与new类型类似，delete表达式也执行两个动作：销毁给定的指针指向的对象；释放对应的内存

悬空指针

当我们delete一个指针后，指针值就变为无效了。虽然地址以及无效，但在很多机器上仍然保存着（以及释放的）动态内存的地址。在delete之后，指针就变成人们所说的悬空指针（dangling pointer），即，指向一块曾经保存数据对象但现在已经无效的内存指针。

我们可以在指针即将离开其作用域之前释放掉它所关联的内存。这样关联指针的内存被释放后，就没机会继续使用指针了。我们可以将nullptr赋予指针，就清楚的指出指针不再指向任何对象。

下面使用一个new和delete的完整案例：

using namespace std;

int main(int argc,char *argv[]){

    int *p(new int()); //指向动态内存

    auto q = p; //q和p指向相同的内存

    //在程序退出之前，一定要delete

    delete p;  //p和q均无效

    p = nullptr; //指出p不再绑定到任何对象

return ;

}

1.3 shared_ptr和new结合使用

我们可以用new返回的指针来初始化智能指针

shared_ptr<double> p1; //shared_ptr可以指向一个double

shared_ptr<double> p2(new int()); //p2指向一个值为42的int

默认情况下，一个用来初始化智能指针的普通指针必须指向动态内存，因为智能指针默认使用delete释放它所关联的对象。我们可以将智能指针绑定到一个指向其他类型的资源的指针上，但是为了这么做，必须提供自己的操作来代替delete。

shared_ptr类和new之间提供很多的相互转化操作，比如shared_ptr的构造函数接受一个new的动态指针。shared_ptr的get()方法返回它所管理的动态指针。虽然shared_ptr提供了丰富的相互转化操作，但是笔者建议不要混合使用普通指针和智能指针，混合使用将会使动态内存的释放问题更加复杂。

例如下面这个程序，在不经意间就会造成指向已经释放内存的错误：

shared_ptr<int> p(new int());   //引用计数为1

int *q = p.get();   //正确：但使用q要注意，不要让它管理的指针被释放

{ //新的块

    shared_ptr<int>(q);   //两个独立的shared_ptr指向相同的内存

}//程序块结束，q被销毁，它指向的内存被释放

int foo = *p;    //未定义：p指向的内存已经被释放了

p和q指向相同的内存。由于它们是相互独立创建的，因此各自的引用计数都是1。当q所在的程序块结束时，q被销毁，这会导致q指向的内存被释放。从而p变成一个悬空指针，意味着当我们试图使用p时，将发生未定义的行为。而且，当p被销毁时，这块内存会被第二次delete。

get用来将指针的访问权限传递给代码，你只有在确定代码不会delete指针的情况下，才能使用get。特别是，永远不要使用get初始化另一个智能指针或者为另一个智能指针赋值。

#include <iostream>

#include <string>

#include <memory>

using namespace std;

int main(int argc,char* argv[]){

    shared_ptr<int> p(new int());

    shared_ptr<int> q(p);

    if(!p.unique())

        p.reset(new string(*p)); //如果我们不是唯一的用户，分配新的拷贝

    *p += "";//我们知道自己是唯一的用户了，可以改变对象的值

return ;

}

1.4 unique_ptr

一个unique_ptr“拥有”它所指向的对象。与shared_ptr不同，某个时刻只能有一个unique_ptr指向一个给定对象。当unique_ptr被销毁时，它所指向的对象也被销毁。

与shared_ptr不同，没有类似的make_shared的标准库函数返回一个unique_ptr。当我们定义一个unique_ptr时，需要将其绑定一个new返回的指针上。类似shared_ptr，初始化unique_ptr必须采用直接初始化。

接下来是一个使用案例：

#include <string>

#include <memory>

using namespace std;

int main(int argc,char *argv[]){

        unique_ptr<string> p1(new string("hello"));

    //将所有权从p1（指向string hello）转移给p2

        unique_ptr<string> p2(p1.release());//release将p1置为空

        unique_ptr<string> p3(new string("world"));

    //将所有权从p3转义给p2

        p2.reset(p3.release());//reset释放了p2原来指向的内存

return ;

}

1.5 weak_ptr

weak_ptr是一种不控制所指向对象生存期的智能指针，它指向由一个shared_ptr管理的对象。将一个weak_ptr绑定到一个shared_ptr不会改变shared_ptr的引用计数。一旦最后一个指向对象的shared_ptr被销毁，对象就会被释放。即使有weak_ptr指向对象，对象也还是会被释放，因此，weak_ptr的名字抓住这种智能指针"弱"共享对象的特点。

当我们创建一个weak_ptr时，要用一个shared_ptr来初始化它：

shared_ptr<int> p = make_shared<int>();

weak_ptr<int> wp(p);  //wp弱共享p;p的引用计数未改变

wp和p指向相同的对象。由于是弱共享，创建wp不会改变p的引用计数；wp指向的对象可能会被释放掉。

由于对象可能不存在，我们不能在weak_ptr上直接访问对象，而是必需要调用lock。
例如：

if(shared_ptr<int> np = wp.lock()){//如果np不为空，则条件成立

    //np与p共享

}

标准库还提供了weak_ptr大量的相关操作函数，读者可以自行翻阅。

1.6 程序异常情况下的资源释放处理

在我们的程序中，当一个程序发生异常时要令发生异常后的程序流继续。我们注意到，这种程序需要确保在异常发生后资源能够被正确的释放。一个简单的确保资源被释放的方法是使用智能指针。

如果使用智能指针，即使程序块过早结束，智能指针类也能确保在不存不再需要时将其释放掉:

void f(){

    shared_ptr<int> sp(new int()); //分配一个新对象

    //这段代码抛出一个异常，且在f中未被捕获

}//在函数结束时，shared_ptr自动释放内存

函数的退出有两种情况，正常处理结束或发生了异常，无论哪种情况，局部对象都会被销毁。在上面的程序中，sp是一个shared_ptr,因此sp销毁时检查引用计数。在此例中，sp是指向这块内存的唯一指针，因此内存会被释放掉。

void f(){

    int *ip = new int(); //动态分配一个新对象

    //这段代码抛出一个异常，且在f中未捕获

    delete ip; //在退出之前释放内存

}

如果在new和delete之间发生异常，且未在f中捕获异常，则内存就永远不会被释放了。

1.7 使用智能指针的陷阱

在使用智能指针时，我们必需坚持一些基本规范：
1.不使用相同的内置指针初始化多个智能指针。
2.不delete get()返回的指针。
3.不使用get()初始化或reset另一个智能指针。
4.如果你使用get返回的指针，记住当最后一个对于的智能指针销毁后，你的指针就变成无效了。
5.如果你使用智能指针管理的资源不是new分配的内存，记住传递给它一个删除器。

2 动态数组

new和delete运算符一次分配/释放一个对象，但某些应用需要一次为很多对象分配内存的功能。例如,vector和string都是连续在内存中保存它们的元素。

c++语句定义了另外一种new表达式语法，可以分配并初始化一个对象数组。标准库中包含一个名为allocator类，允许我们将分配和初始化分离。

2.1 new管理动态数组内存

为了让new分配一个对象数组，我们要在类型名之后跟一对方括号，在其中指明要分配对象的数目。例如：

//调用get_size确定分配多少个int

int *pia = new int[getsize()];   //pia指向第一个int

方括号的大小必须是整数，不必是常量。

也可以使用数组的类型别名：

typedef int arrT[];  //arrT表示42个int的数组类型

int *p = new arrT;    //分配一个42个int的数组；p指向第一个int

我们通常称new T[]分配的内存为“动态数组”，但这种叫法某种程度上有些误导。当用new分配一个数组时，我们并未得到一个数组类型的对象，而是得到一个数组类型的指针。

释放动态数组

为了释放动态数组，我们使用一种特殊的形式的delete-在指针前加上一个空括号对：

delete p;     //p必须指向一个动态分配的对象或为空

delete []pa;   //pa必须指向一个动态分配的数组或为空

当我们释放一个指向数组的指针时，空方括号是必须的：它指示编译器此指针指向一个对象数组的第一个元素。如果我们在delete一个指向数组的指针时忽略了方括号（或者在delete一个指向单一对象的指针时使用了方括号），其行为都是未定义的。

typedef int arrT[]; //arrT是42个int的数组的类型别名

int *p = new arrT;    //分配一个42个int的数组；p指向第一个元素

delete[] p;           //方括号是必须的，因为我们分配是的是一个数组

在最后说一个shared_ptr对动态数组的操作，shared_ptr不支持直接管理动态数组，要使用动态数组，必需自定义删除器：

#include <memory>

using namespace std;

int main(int argc,char* argv[]){

    //提供一个删除器，默认的删除器是delete T,我们这里是数组，也就应该是delete[] T，所以应该提供delete[]格式的删除器

    shared_ptr<int> sp(new int[],[](int *p){delete []p}):

    //shared_ptr未定义下标运算符，并且不支持指针的算术运算

    for(size_t i = ; i != ; i++)    {

        *(sp.get() + i) = i;  //get()获取一个内置指针

    }

    sp.reset(); //使用我们的lambda释放数组，它使用delete[]

return ;

}

2.2 allocator管理动态数组内存

new有一些灵活性上的局限，其中一方面表现在它将内存分配和对象构造组合在了一起。类似的，delete将对象析构和内存释放组合在一起。

标准库的allocator类帮助我们将内存分配和对象构造分离开来。它提供一个类型感知的内存分配方法，他分配的内存是原始的、未构造的。

#include <memory>

#include <iostream>

#include <string>

using namespace std;

int main()

{

    int n = ;

    allocator<string> alloc;

    string* const p = alloc.allocate(n);

    //为了使用allocate分配的内存，必须使用construct来构造对象。

    string* q = p;

    alloc.construct(q++);        //*q为空字符串

    alloc.construct(q++,,'c');    //*q为ccccc

    alloc.construct(q++,"hi");     //*q为hi

    cout << *p << endl;   //正确

    cout << *q << endl;   //灾难：指向未构造的内存

    while(q != p){

        alloc.destroy(--q);  //释放我们构造的string

    }

    //一旦元素被释放后，我们就可以使用这部分内存来保存其它string,

    //也可以将其归还给给系统

    //归还内存给系统

    alloc.deallocate(p,n);

}