动态数组

$new$ 与 $delete$

class Node {
public:
    int a;
    Node() {
        a = 1;
    }
    Node(int x) : a(x){}
    ~Node() {
        cout << "********" << endl;
    }
};

int L, W, H;
L = 2;
W = 2;
H = 2;
Node ***array = new Node **[H];
for (int i = 0; i < H; i++) {
    array[i] = new Node *[L];
    for (int j = 0; j < L; j++) {
        array[i][j] = new Node[W];
    }
}
for (int i = 0; i < H; i++) {
    for (int j = 0; j < L; j++) {
        delete[] array[i][j];
    }
    delete array[i];
}
delete array;
/*
********
********
********
********
********
********
********
********
*/

char arr[0];//错误
char *arr = new char[0];//正确

当用 $new$ 分配一个大小为0的数组的时候，$new$返回一个合法的非空指针。此指针保证与$new$返回的其他任何指针都不相同。此指针可以加减0，但是不能解引用。

$delete[]$会销毁数组中的元素并释放对应的内存，数组中的元素按逆序销毁。$new$会调用构造函数，$delete$会调用析构函数。

class Node {
public:
    int a;
    Node() {
        a = 1;
        cout << a << endl;
    }
    Node(int x) : a(x){ 
        cout << a << endl; 
    }
    ~Node() {
        cout << a << endl;
    }
};
Node *a = new Node[5]{ 1,2,3,4,5 };
delete[] a;
/*
1
2
3
4
5
5
4
3
2
1
*/

智能指针与动态数组

$unique\_ptr$可以管理动态数组：

unique_ptr<int []> up(new int[10]);
up.release();//自动调用delete[] 销毁指针

up[i];//调用

$shared\_ptr$无法直接管理动态数组，必须提供定义的删除器，并且访问数组中的元素需要用get：

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


for( size_t i = 0; i != 10; i++)
    *(sp.get() + i) = i;

$allocator$

$allocator$非配原始的、未构造的内存。

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

auto q = p;
alloc.construct(q++);
alloc.construct(q++,10,'c');
alloc.construct(q++, "hi");

cout << *p << endl;//正确
cout << *q << endl;//错误，未构造的内存

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

alloc.deallocator(p, n);

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

函数均返回一个指针，指向最后一个构造元素之后的位置。

auto p = alloc.allocator(vi.size() * 2);
auto q = uninitialized_copy( vi.begin(), vi.end(), p );
uninitialized_fill_n(q, vi.size(),  42);