动态内存分配与智能指针

内存分配：

静态存储区：

局部static对象
类的static数据成员
定义在任何函数之外的变量

栈区：

函数内的非static对象

动态内存分配的方式有：

new和delete
智能指针（shared_ptr、unique_ptr、weak_ptr）
allocator类
malloc和free

直接管理内存：

运算符new分配内存，delete释放new分配的内存。

int* p = new int ();//new表达式在自由空间构造一个对象，并返回指向该对象的指针。
delete p;
int* pi = new int[10]();//分配一个10个int的数组，pi指向第一个int。

默认情况下，动态分配的对象是默认初始化的，这意味着内置类型或者组合类型的对象的值是未定义的，而类类型对象将用默认构造函数进行初始化。
用new分配const对象是合法的，但const对象必须进行初始化。
如果一个程序用光了所有可用的内存，new表达式会失败，并抛出bad_alloc异常，该异常可以通过nothrow阻止，阻止异常抛出的new称为定位new。

int* p1 = new int;//如果分配失败，new抛出std::bad_alloc。
int* p2 = new (nothrow)int;//如果分配失败，new返回一个空指针。

delete表达式也执行两个动作：销毁一个给定的指针指向的对象；释放对应的内存。
传递给delete的指针必须指向动态分配的内存，或者是一个空指针，释放一个并非new分配的内存，或者将相同的指针值释放多次，其行为是未定义的。
释放动态数组时，数组中的元素按逆序销毁。
释放一个const动态对象，只要delete指向它的指针即可。

const int* pci = new const int(1024);
delete pci;

直接管理内存容易犯的错：

忘记delete内存（内存泄漏）
使用已经释放掉的对象
同一块内存释放两次

空悬指针/野指针（dangling pointer）：指向一块曾经保存数据对象但现在已经无效的内存的指针。
产生原因：指针变量声明时未初始化或者指针被delete或free后未置为nullptr以及指针操作超越了变量的作用范围。

智能指针：

shared_ptr允许多个指针指向同一个对象
unique_ptr“独占”所指向的对象
weak_ptr指向一个shared_ptr管理的对象，它不控制指向对象的生存期。

shared_ptr：
初始化：

shared_ptr<string> p1;//默认初始化的智能指针保存着一个空指针

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

if (p1 && p1->empty()) {*p1 = "hi";//如果p1指向一个空string，解引用p1,将一个新值赋予string。
}

make_shared函数：
类似顺序容器的emplace成员，make_shared用其参数来构造给定类型的对象。

shared_ptr<int> pi = make_shared<int>(42);

引用计数：
每个shared_ptr都有一个关联的计数器，通常称其为引用计数。无论何时我们拷贝一个shared_ptr，或将其作为参数传递给一个函数以及作为一个函数的返回值时，它所关联的计数器就会递增。当我们给shared_ptr赋予一个新值或者是shared_ptr被销毁时，计数器就会递减。当一个shared_ptr的计数器变为0，他就会自动释放自己所管理的对象。

程序使用动态内存的三个原因：

程序不知道使用多少个对象（容器类）
程序不知道所需对象的具体类型
程序需要在多个对象间共享数据

shared_ptr与new的结合：
接受指针参数的智能指针构造函数是explicit的，因此我们不能将一个内置指针隐式转换为一个智能指针，必须使用直接初始化的形式。

shared_ptr<int> p1 = new int(1024);//错误
shared_ptr<int> p1(new int(1024));//正确

如果想用shared_ptr管理动态数组，必须提供自己定义的删除器，并且不支持下标操作。

shared_ptr<int> sp(new int[10],[](int *p){delete [] p ;});
sp.reset();

正确使用智能指针的规范：

使用相同的内置指针值初始化（或reset）多个智能指针。
不delete get() 返回的指针。
不使用get()初始化或reset另一个智能指针。
如果你使用get（）返回的指针，记住当最后一个对应的智能指针销毁后，你的指针就变为无效了。
如果你使用智能指针管理的资源不是new分配的内存，记住传递给它一个删除器。

unique_ptr:
当我们定义unique_ptr时，需要将其绑定到一个new返回的指针上，而且必须采用直接初始化的形式。
由于unique_ptr“独占”它指向的对象，因此unique_ptr不支持拷贝或赋值操作。
虽然我们不能拷贝和赋值unique_ptr，但可以调用release或reset将指针所有权从一个（非const）unique_ptr转移给另一个unique:

unique_ptr<string> p1(new string("first"));
unique_ptr<string> p2(p1.release());//将所有权从p1转向p2,p1被置为空
unique_ptr<string> p3(new string ("second"));
//将所有权从p3转移给p2.
p2.reset(p3.release());//reset释放了p2原来指向的内存。

unique_ptr可以管理动态数组，必须在对象类型后面跟一对空方括号，支持下标操作。

unique_ptr<int[]> up(new int[10]);
up.release();//自动用delete[]销毁其指针。
for(size_t i = 0 ; i != 10 ; i++)
{up[i] = i;
}

weak_ptr:
weak_ptr不控制所指向的对象的生存期，指向一个由shared_ptr管理的对象。将一个weak_ptr不会改变shared_ptr的引用计数。一旦最后一个指向对象的shared_ptr被销毁，对象就会被释放。
由于对象可能不存在，不能使用weak_ptr直接访问对象，必须调用lock。此函数检查weak_ptr指向的对象是否仍存在。如果存在，lock返回一个指向共享对象的shared_ptr。
可以解决两个shared_ptr互相引用的问题。

allocator类：

将内存分配和对象构造分离开，提供一种类型感知的内存分配方法，他分配的内存是原始的、未构造的。
定义一个allocator对象，必须指明这个allocator可以分配的对象类型。当一个allocator对象分配内存时，它会根据给定的对象类型来确定恰当的内存大小和对齐位置：

allocator<string> alloc;//可以分配string的allocator对象
auto const p = alloc.allocate(n);//分配n个未初始化的string。
auto q = p;
alloc.construct(q++);//*q为空字符串
alloc.construct(q++,10,'c');//*q为cccccccccc
alloc.construct(q++,"hi");//*q为hi
cout<<*p<<endl;//正确:使用string的输出运算符
cout<<*q<<endl;//灾难：q指向未构造的内存
while(q!=p)alloc.destroy(--q);//释放我们真正构造的string
//destory接受一个指针，对指向的对象执行析构函数。
alloc.deconstruct(p,n);//通过deallocate释放内存。
//传递给deallocate的指针不能为空，它必须指向由allocate分配的内存。而且传递给deallocate的大小参数必须与调用allocated分配内存时提供的大小参数具有一样的值。