动态数组

new和delete运算符一次分配/释放一个对象，但某些应用需要一次为很多对象分配内存，如vector和string都是在连续内存中保存元素。因此当容器需要重新分配内存时，必须一次性就进行分配。

C++和STL具有两种一次分配一个对象数组的方法。C++定义了另一种new表达式语法可以分配并初始化一个对象数组。标准库中包含一个名为allocator的类，允许将分配和初始化分离。

而通常情况下，大多应用没有直接访问动态数组的需求。当一个应用需要可变数量的对象时，在前述StrBlob中采用vector的方法往往更简单、快速和安全。因为容器类可以使用默认版本的拷贝、赋值和析构操作。分配动态数组的类则必须定义自己版本的操作，在拷贝、复制以及销毁对象时管理所关联的内存。

new和数组

为了让new分配一个对象数组，要在类型名之后跟一对方括号，在其中指明要分配的对象数目。方括号中的大小必须是整形但可以不是常量：

int get_size(){return this->size()};
int* arr = new int[get_size()];

分配一个数组会得到一个元素类型的指针

在使用new T[]分配内存时，并未得到一个数组类型的对象而是一个相应数组元素类型的指针。即使使用了数组的类型名也不会改变这一点。因此“动态数组”的实现方式依然是一个指针。

由于分配到内存不是数组类型，不能对动态数组调用begin或end，以及范围for等。

初始化动态分配对象的数组

默认情况下new分配的对象都是默认初始化，但同时可以进行值初始化，同样是加括号即可，新标准还支持列表初始化（剩余元素值初始化，超出则抛出bad_array_new_length异常）：

int* pia1 = new int[5];
int* pia2 = new int[5]();
int* pia3 = new int[5]{1,2,3};

动态分配一个空数组是合法的

先分配再进行元素处理：

int* pia = new int[n];
for (int* q = p; q != p + n; q++){
    //处理数组元素
}

若使用new分配了一个大小为0的数组，返回的是合法的非空指针，但返回的其他任何指针都不相同：可以加减0；可以进行比较；可以减去自身得到0；但是不能解引用，因为不指向任何元素。

释放动态数组

释放动态数组需要特殊形式的delete，需要再指针名之前加一对空方括号：

delete [] pia;

智能指针和动态数组

标准库中提供了可以管理new分配到数组的unique_ptr版本。为了用一个unique_ptr管理动态数组，必须在<对象类型>后面跟一对方括号；而销毁该unique_ptr时会自动使用delete[]：

unique_ptr<int[]> up(new int[5]);
up.release();

指向数组的unique_ptr提供的操作与指向对象的有所不同：

• 不能使用点（箭头）运算符
• 新增使用下标运算符（对指针本身而不是解引用使用下标）

std::unique_ptr<int[]> up(new int[6]());
for(size_t i = 0; i != 5; i++) up[i] += i;
std::cout<<up[4];

与unique_ptr不同，shared_ptr不直接支持管理动态数组，需要为其提供自定义删除器来实现：

auto del_sp = [](int* p){delete[] p};
shared_ptr<int> sp(new int[10](), del_sp);
sp.reset();      //自动调用提供的lambda作为删除器

同时，shared_ptr没有支持下标的版本，因此访问元素需要使用get返回的指针继续操作：

std::shared_ptr<int> sp(new int[6](), [](int* p){delete[] p;});
auto p = sp.get();
for(size_t i = 0; i != 5; i++) {
    //可以将get的返回对象保存到另一个指针
    *(p++) += (i + 2);
    //另一种访问方式，get返回值+偏移量
    std::cout<<*sp.get()+i;     //23456
}

allocator类

new有一些灵活性的局限：它将内存分配和对象构造组合在一起，如同delete将对象析构和内存释放组合在一起。

分派大块内存时常常需要将内存分配和对象构造分离；此外，若没有默认构造函数的类无法动态分配数组。因此就需要使用allocator。

allocator

标准库allocator类定义在头文件<memeory>中。它提供一种类型感知的内存分配方式，分配的内存是原始的、未构造的。

类似vector，allocator是一个模板。为了定义这个对象，必须指明这个allocator可以分配的对象类型。当一个allocator对象分配内存时，会根据给定对象类型确定恰当的内存大小和对齐位置。

注：动态分配的，英文dynamically allocated

allocator<string> alloc;           //实例化一个string的allocator
auto const p = alloc.allocate(n);  //分配n个未初始化的string

基本步骤：创建allocator对象->allocate初始化指针->由指针construct原始内存->destroy析构->deallocate释放内存

allocator分配的是未构造的内存

allocator分配的是未构造（unconstructed）的内存。为了按需在该内存中构造对象。新标准中，construct成员函数接受一个指针和零个或多个额外参数，在给定位置构造一个元素。

额外参数用来初始化构造的对象，类似make_shared的参数，这些额外参数必须是与构造的对象的类型相匹配的合法的初始化器。

未构造对象就使用原始内存是错误的

allocator<string> alloc;
auto const* p = alloc.allocate(10);
auto q = p;
alloc.construct(q++);
alloc.construct(q++, 3, 'X');
alloc.construct(q++, "Hello");

cout<<*q;  //非法：q指向的是为构造的内存
cout<<*p;  //正确，allocate的首内存位置

用完对象后必须对每个构造的元素调用destroy进行销毁，destroy接受一个指针，因此使用上述的双指针相当有效：

while(p != q) alloc.destroy(--q);

拷贝和填充未初始化内存的算法

allocator类中有两个伴随算法，可以在未初始化内存中创建对象。这些算法都定义在头文件memeory中：