[Note] C++动态内存：智能指针、动态数组

C++ Primer 动态内存

先简单介绍一下我们常用的几种内存：静态内存、栈内存、动态内存
1）从静态内存分配空间，内存在程序编译的时候就已经被分配好，比如全局变量和static变量
2）栈内存是在执行函数时，函数内部定义局部变量所分配的内存，在函数结束时，这些内存就被释放，效率比较高，但栈空间往往较小
3）动态内存，又称堆，由程序员自主通过malloc或new来分配，通过free和delete来进行释放。如果忘记释放，就会造成内存泄漏;如果在尚有指针引用内存的情况下释放内存，就会产生引用非法内存的指针

一、智能指针

为了更容易地使用动态内存，C++提供了两种智能指针类型来管理动态对象。智能指针的行为类似常规指针，但是它们可以自动释放所指向的对象。shared_ptr允许多个指针指向同一个对象，unique_ptr则独占所指向的对象。

1. shared_ptr
头文件：memory
智能指针是模板类。其创建方法如下：

shared_ptr<string> p1;
shared_ptr<vector<int>> p2;

默认初始化为一个空指针。

智能指针的使用方式和普通指针类似：

if(p1 && p1->empty()) //如果p1为空，则将“hi”赋予string
        *p1 = "h1";

还有其他一些用法：
1）shared_ptr和unique_ptr都支持的用法

p.get();//返回p中保存的指针
swap(p,q);//交换p和q中指针
q.swap(p);

2）仅有shared_ptr支持的操作

make_shared<T>(args);//返回一个shared_ptr指向一个T对象，并用args初始化对象
shared_ptr<T> p(q);//p是q的拷贝，此操作递增q中计数器
p = q;//递减p中计数器，递增q中计数器
p.unique();//若p.use_count()为1,返回true，否则false
p.use_count();//返回指针的引用计数，一旦计数为0,指针会释放自己管理的对象

使用动态内存的原因：
1）程序不知道自己需要使用多少对象
2）程序不知道所需对象的准确类型「
3）程序需要在多个对象之间共享数据

下面我们看一个处于第3个原因使用动态内存的例子：

template<typename T>
class Test{
public:
    Test():data(make_shared<vector<T>>()){}
    Test(std::initiallizer_list<T> li):data(make_shared<vector<T>>(li)){}
    void pop_back() {data->pop_back();}
    T& top() const {return data->back();}
    bool empty() const {return data->empty();}
    size_t size() const {return data->size();}
    void push_back(const T& d){data->push_back(d);}
private:
    shared_ptr<vector<T>> data;
};

使用new和delete管理动态内存的一些实例
因为这个在之前已经学过，简单的列几个例子：

string *s = new string;
string *s = new string("2333");
auto p = new auto(obj);//括号中必须只有单一初始化器才能这么用
auto p = new auto({a,b});//错误用法
//正常情况下，new失败会抛出std::bad_alloc异常
int * p = new (nothrow) int;//若分配失败，返回空指针
delete p;
delete []p;

shared_ptr和new结合使用
shared_ptr<int> p(new int(10));//正确用法
shared_ptr<int> p = new int();//错误用法
shared_ptr<int> f(){
    return new int;//错误用法
}
shared_ptr<int> f(){
    returb shared_ptr<int>(new int);//正确用法
}

定义和改变shared_ptr的其他办法

1）shared_ptr<T> p(q);
p管理内置指针q所指向的对象，q必须指向new分配的内存，且能转换成T×类型
2）shared_ptr<T> p(u);
p从unique_ptr u哪里接管对象的所有权，并将u置为空
3）shared_ptr<T> p(q,d);
p接管内置指针q所指向对象的所有权，p将使用可调用对象d来代替delete
4）shared_ptr<T> p(p2,d);
p是shared_ptr p2的拷贝，并p调用可调用对象d来代替delete

5）
p.reset();
如果p是唯一指向对象的shared_ptr，reset会释放此对象
p.reset(q);
若传递了可选的参数内置指针q，会令p指向q，否则将p置空
p.reset(q,d);
若还传递了可选参数d，将会调用d而不是delete释放q

注意：虽然C++提供了内置指针和智能指针的转换，但是请尽量避免两种指针混合使用

2. unique_ptr
与shared_ptr不同的是，某个时刻只能有一个unique_ptr指向一个给定对象，当ptr被销毁时，它所指向的对象也被销毁
其基本操作在前面已经列出，与shared_ptr不同的是，定义一个unique ptr时，必须将它绑定到一个new返回的指针上

unique_ptr<double>  p1;
unique_ptr<int> p2(new int(43));

因为一个unique拥有一个对象，所以它不支持普通的拷贝或赋值操作

unique_ptr支持的其他操作
1)unique_ptr<T,D> u2;
定义一个空的u2,u2会使用一个类型为D的可调用对象来释放它的指针
2)unique_ptr<T,D> u(d);
定义一个空的u，指向类型为T的对象，用类型为D的对象d代替delete
3)u = nullptr;
释放u指向的对象，将u设为空
4)u.release();
u放弃对指针的所有权，返回指针，并将u置为空
5)
u.reset();
释放u指向的对象
u,reset(q);
如果提供了内置指针q，则令u指向这个对象，否则将u置空
u.reset(nullptr);

3.weak_ptr
weak_ptr是一种不控制所指向对象生存周期的智能指针，它指向一个由shared_ptr管理的对象，将一个weak_ptr绑定到shared_ptr不会改变shared_ptr的引用计数
用法：

weak_ptr<T> w;
weak_ptr<T> w(sp);
w = p;//p 为weak ptr或者shared ptr
w.reset();//将w置为空
w.use_count();
w.expired();//若w.use_count()为0,则为true，否则false
w.lock();//返回shared_ptr，或nullptr

二、动态数组

new和delete只能一次分配释放一个对象，一些场合，我们需要一次为很多对象分配内存，为了支持这种需求，C+=和标准库提供乐两种方法：new和allocator

1. new和数组
一些基本语法：

int *a = new int[get_size()];
int *a = new string[100]();
int *a = new string[10]{"a","b","c",string(3,'x')};
typedef int att[10];
int *a = new att;
delete []a;

智能指针和动态数组
可以用unique_ptr管理动态数组，语法如下：

unique_ptr<int[]> up(new int[10]);
up[i] = 10;
up.release();//自动调用delete[]释放指针

此时
指向数组的unique ptr不支持成员访问运算符即 点 和 箭头 运算符
其他的unique ptr操作保持不变

与unique_ptr不同，shared_ptr不支持直接管理动态数组，需要自己ingoing删除器

shared_ptr<int> sp(new int[10],[](int *p){delete []p;});//此处使用了lambda表达式
shared_ptr未定义下标运算符，访问数组元素很麻烦
*(sp.get()+i) = i; //i为我们要访问的下标

2.allocator类

new和delete有一些灵活性的局限，它们将多个对象的构造和内存分配绑定在一起，有时这会造成浪费
allocater类定义在头文件memory中，它帮助我们将对象构造和内存分配分离凯，它提供一种类型感知的内存分配方法，它分配的内存是原始的，未构造的

基本用法：

allocator<T> a;//定义allocator对象，它可以为类型为T的对象分配内存
auto p = a.allocate(n);//分配一段原始的、未构造的内存，保存n个类型为T的对象
a.deallocate(p,n);//释放从T×指针 p中地址开始的内存，n必须是a.allocate(n)中的n，在这之前， 用户需要对在这块内存中创建的对象调用destroy
a.construct(p,args);//在p指向的内存中构造一个对象
a.destroy(p);//对p指向的对象执行析构函数

例如，为string分配内存、构造对象、释放对象：

allocator<string> alloc;
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++,"h1");//*q为hi

while(q!=p)
    alloc.destroy(q--);//被销毁后，可以重新构造
alloc.deallocate(p,n);

标准库还为allocator类定义了两个伴随算法，用来进行拷贝和填充操作：

uninitialized_copy(b,e,b2);//从迭代器b和e指出的范围中拷贝元素到迭代器b2开始的未构造内存中
uninitialized_copy(b,n,b2);//将从迭代其b开始n个元素拷贝到迭代器b2开始的内存中
uninitialized_fill(b,e,t);//在迭代器b和e指出的范围中创建t的拷贝对象（多个）
uninitialized_fill(b,n,t);//从b开始的内存中创建n个t对象