动态内存2(动态数组)

在 c++11 中提供了两种一次分配一个对象数组的方法。其一是使用一种 new 表达式语法，其二是使用一个名为 allocator 的类。虽然通常我们更希望用容器来代替数组(使用容器的类可以使用默认版本的拷贝、赋值和析构操作。分配动态数组的类则必须定义自己版本的操作，在拷贝、复制以及销毁对象时管理所关联的内存)

new 和数组：

#include <iostream>
using namespace std;

int main(void){
    int size = 10;
    int *a = new int[size];//a指向第一个int
    //方括号中的大小必须是整型,但不必是常量

    //使用类型别名
    typedef int arrT[10];//arrT表示10个int的数组类型
    int *b = new arrT;//等价于 int *b = new int[10];

    return 0;
}

注意：通常我们称 new T[] 分配的内存为 "动态数组"，但是当 new 分配一个数组时我们并未得到一个数组类型的对象，而是得到一个数组元素类型的指针。因此我们不能对其调用 begin 或 end，也不能使用范围 for 循环来处理动态数组中的元素

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

#include <iostream>
using namespace std;

int main(void){
    int *a = new int[10];//10个未初始化的int
    int *b = new int[10]();//10个值初始化为0的int
    string *s1 = new string[10];//10个空string
    string *s2 = new string[10]();//10个空string

    //列表初始化
    int *c = new int[10]{2, 3, 4, 2};//剩余元素值初始化为0
    string *s3 = new string[10]{"d", "f", "ew"};//剩余元素值初始化为空string


// 对于单个对象分配动态内存,我们可以在圆括号中给出初始化器,因此可以使用auto推导
// 对于分配动态数组,我们虽然可以用圆括号表示值初始化,但不能在圆括号中给出初始化器,因此不能用auto推导
    auto s4 = new auto("jfl");

//我们可以通过给数组命名类型别名解决这个问题
    typedef int arrT[10];
    auto e = new arrT;
    auto f = new arrT();//我们同样可以在后面加一个圆括号来使用值初始化
    for(auto indx = f; indx != f + 10; ++indx){
        cout << *indx << " ";
    }
    cout << endl;//0 0 0 0 0 0 0 0 0

    //动态分配一个空数组是合法的
    const int maxn = 0;
    int *d = new int[maxn]();
    for(auto indx = d; indx != d + maxn; ++indx){//maxn为0,并不会发生越界
        cout << *indx << endl;
    }

    return 0;
}

注意：如果初始化器数目小于元素数目，剩余元素会进行值初始化，反之则会抛出 bad_array_new_length 异常

对于分配动态数组，我们虽然可以用圆括号表示值初始化，但不能在圆括号中给出初始化器，因此不能直接用 auto 推导。当然我们可以通过类型别名解决这个问题

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

释放动态数组：

#include <iostream>
using namespace std;

int main(void){
    int *a = new int[10];
    delete []a;

    //使用类型别名来定义一个数组类型时,在new表达式中不使用[].但在释放一个数组指针时必须使用[]
    typedef int arrT[10];
    auto b = new arrT;
    delete[] b;

    return 0;
}

注意：使用类型别名来定义一个数组类型时，在new表达式中不使用[]。但在释放一个数组指针时必须使用[]

智能指针和动态数组：

标准库提供了可以管理 new 分配的数组的 unique_ptr 版本：

#include <iostream>
#include <memory>
using namespace std;

class gel{
private:
    int x;

public:
    gel(int a) : x(a) {}
    gel() : gel(0) {}
    ~gel() {
        cout << "~gel" << endl;
    }
};

int main(void){
    unique_ptr<gel[]> up(new gel[2]);
    up.reset();//自动调用delete[]销毁其指针
    cout << "===" << endl;
    // 输出：
    // ~gel
    // ~gel
    // ===

    return 0;
}

注意：当 unique_ptr 调用 reset 销毁它管理的动态数组时，会自动调用 delete[]

同样，和动态分配单个对象的 unique_ptr 一样，当 unique_ptr 离开其作用域时会被自动销毁：

#include <iostream>
#include <memory>
using namespace std;

class gel{
friend ostream& operator<<(ostream&, const gel&);

private:
    int x;

public:
    gel(int a) : x(a) {}
    gel() : gel(0) {}
    ~gel() {
        cout << "~gel" << endl;
    }
};

ostream& operator<<(ostream &os, const gel &it){
    os << it.x;
}

int main(void){
    unique_ptr<gel[]> up(new gel[2]);
    cout << "===" << endl;
    // 输出：
    // ===
    // ~gel
    // ~gel

    return 0;
}

当一个 unique_ptr 指向的是一个数组而不是单个对象时，我们不能使用点和箭头运算符，这是没意义的。但我们可以使用下标运算符来访问数组中的每个元素：

#include <iostream>
#include <memory>
using namespace std;

class gel{
friend ostream& operator<<(ostream&, const gel&);

private:
    int x;

public:
    gel(int a) : x(a) {}
    gel() : gel(0) {}
    ~gel() {
        // cout << "~gel" << endl;
    }
};

ostream& operator<<(ostream &os, const gel &it){
    os << it.x;
}

int main(void){
    unique_ptr<gel[]> up(new gel[3]{gel(1), gel(2), gel(3)});
    for(int i = 0; i < 3; i++){
        cout << up[i] << " ";
    }
    cout << endl;//1 2 3

    return 0;
}

指向数组的 unique_ptr 的操作：

指向数组的 unique_ptr 不支持成员访问运算符(点和箭头运算符)。其它 unique_ptr 操作不变

unique_ptr<T[]> u　　　　u 可以指向一个动态分配的数组，数组元素类型为 T

unique_ptr<T[]> u(p)　　   u 指向内置指针 p 所指向的动态分配数组。p 必须能转为类型 T*

u[i]　　　　　　　　　　  返回 u 拥有的数组中位置 i 处的对象。u 必须直向一个数组

shared_ptr 不直接支持管理动态数组。如果希望 shared_ptr 管理一个动态数组，必须提供自己定义的删除器，并且 shared_ptr 管理数组也不支持下标访问：

#include <iostream>
#include <memory>
using namespace std;

class gel{
friend ostream& operator<<(ostream&, const gel&);

private:
    int x;

public:
    gel(int a) : x(a) {}
    gel() : gel(0) {}
    ~gel() {
        cout << "~gel" << endl;
    }

    gel& operator+=(const int &it){
        x += it;
        return *this;
    }
};

ostream& operator<<(ostream &os, const gel &it){
    os << it.x;
    return os;
}

int main(void){
    shared_ptr<gel> sp(new gel[3]{gel(1), gel(2), gel(3)},
        [](gel *p){
            delete[] p;
        });

    for(size_t i = 0; i < 3; i++){
        *(sp.get() + i) += 1;
        cout << *(sp.get() + i) << " ";
    }
    cout << endl;

    sp.reset();

    // 输出：
    // 2 3 4
    // ~gel
    // ~gel
    // ~gel

    return 0;
}

allocator 类：

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

将内存分配和对象构造组合在一起可能会导致不必要的浪费：

#include <iostream>
#include <memory>
using namespace std;

int main(void){
    const int manx = 1000;
    string *const p = new string[manx];
    string s;
    string *q = p;
    while(cin >> s && q != p){
        *q++ = s;
    }
    const size_t size = q - p;
    
    //使用数组

    delete[] p;

    return 0;
}

注意：这里我们分配并初始化了 maxn 个 string。但是我们可能并不需要 maxn 个 string。这样我们可能就多创建并初始化了一些永远也用不到的对象。而且，每个要使用到的元素都被赋值了两次，第一次是在默认初始化时，随后是在赋值时

更重要的是，对于那些没有默认构造函数的类，动态分配数组时我们必须对其中的每个元素都用对应的构造函数显示的初始化。对于比较大的数组来说这显然是不现实的。

在头文件 memory 中定义了一个模板类 allocator 能帮助我们将内存分配和对象构造分离开来。它提供了一种类型感知的内存分配方法，它分配的内存是原始的、未构造的。

标准库 allocator 类及其算法：

allocator<T> a　　　  定义了一个名为 a 的 allocator 对象，它可以为类型为 T 的对象分配内存

a.allocate(n)　　　　  分配一段原始的、未构造的内存，确保 n 个类型为 T 的对象，返回该内存块首字节指针

a.deallocate(p, n)　　 释放从 T* 指针 p 中地址开始的内存，这块内存保存了 n 个类型为 T 的对象；p 必须是

　　　　　　　　　　一个先前由 allocate 返回的指针，且 n 必须是 p 创建时所要求的大小。在调用 deallocate

　　　　　　　　　　前，用户必须对每个在这块内存中创建的对象调用 destroy

a.construct(p, args)     p 必须是一个类型为 T* 的指针，指向一块原始内存；args 被传递给类型为 T 的构造函数，

　　　　　　　　　　用来在 p 所指向的内存中构造一个对象

a.destroy(p)　　　　  p 为 T* 类型的指针，此算法对 p 指向的对象执行析构函数

allocator 分配原始内存，构造对象，析构对象，释放内存：

#include <iostream>
#include <memory>
using namespace std;

int main(void){
    const size_t manx = 10;
    allocator<string> alloc;//可分配 string 的 allocator 对象
    auto const p = alloc.allocate(manx);//分配 n 个未初始化的 string

    auto q = p;//q指向最后构造的元素之后的位置
    alloc.construct(q++);//*q为空字符串
    alloc.construct(q++, 3, 'c');//*q为ccc
    alloc.construct(q++, "hi");//*q为hi

    auto p1 = p;
    while(p1 != q){
        cout << *p1++ << " ";
    }
    cout << endl;// ccc hi

    // cout << *q << endl;//不能使用还未构造的原始内存

    //用完对象后，必须对每个构造的原始调用 destroy 来销毁它们
    while(q != p){
        alloc.destroy(--q);//destroy接受一个指针,对指向的对象执行析构函数
    }

    //一旦元素被销毁后,就可以重新使用者部分内存来保存其它string,或将其归还系统
    alloc.deallocate(p, manx);//p必须指向由allocate分配的内存,且maxn必须与调用分配内存时提供的大小参数具有相同的值

    return 0;

}

注意：不能使用为构造的内存

一旦元素被销毁后，就可以重新使用者部分内存来保存其它对应的对象，或将其归还系统

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

allocator 算法：

这些函数在给定目的位置创建原始，而不是由系统分配内存给它们

uninitialized_copy(b, e, b2)　　从迭代器 b 和 e 指出的输入范围中拷贝元素到迭代器 b2 指定的未构造的原始内存中。

　　　　　　　　　　　　　　b2 指向的内存必须足够大，能够容纳输入序列中元素的拷贝

uninitialized_copy_n(b, n, b2)   从迭代器 b 指向的元素开始，拷贝 n 个元素到 b2 开始的内存中

uninitialized_fill(b, e, t)　　　　在迭代器 b 和 e 指定的原始内存范围中创建对象，对象的值均为 t 的拷贝

uninitialized_fill_n(b, n, t)　　   从迭代器 b 指向的内存地址开始创建 n 个值为 t 的拷贝的对象

注意：uninitialized_fill 没用返回值,其余三个函数返回指向最后复制的元素后一元素的迭代器

例：

#include <iostream>
#include <memory>
#include <vector>
using namespace std;

int main(void){
    vector<int> vt = {1, 2, 3, 4, 5};
    const size_t maxn = vt.size() << 2;

    allocator<int> alloc;
    const auto p = alloc.allocate(maxn);

    auto q = uninitialized_copy(vt.begin(), vt.end(), p);
    q = uninitialized_copy_n(vt.begin(), vt.size(), q);
    uninitialized_fill(q, q + vt.size(), 0);
    uninitialized_fill_n(q + vt.size(), vt.size(), 1);
    //注意：uninitialized_fill 没用返回值,其余三个函数返回指向最后复制的元素后一元素的迭代器

    q = p;
    while(q != p + maxn){
        cout << *q++ << " ";
    }
    cout << endl;//1 2 3 4 5 1 2 3 4 5 0 0 0 0 0 1 1 1 1 1

    while(q != p){
        alloc.destroy(--q);//销毁元素
    }

    alloc.deallocate(p, maxn);//释放内存

    return 0;
}