C++语言和标准库提供了两种一次分配一个对象数组的方法。C++语言定义了另一种new表达式语法,可以分配并初始化一个对象数组。标准库中包含一个名为allocator的类,允许我们将分配和初始化分离。使用allocator通常会提供更好的性能和更灵活的内存管理能力。

new和数组

为了让new分配一个对象数组,我们要在类型名之后跟一对方括号,在其中指明要分配的对象的数目。在下例中,new分配要求数量的对象并(假定分配成功后)返回指向第一个对象的指针:

int get_size_new()
{
    return 42;
}
void new_array()
{
    int *p_array = new int[get_size_new()]();
    for (int i = 0; i < get_size_new(); i++)
    {
        cout << *(p_array + i) << " ";
    }

    delete[] p_array;
    cout << endl;
}

在main函数中调用new_array会输出42个0,因为new 分配的数组初始值都为0。 为了释放动态数组,我们使用一种特殊形式的delete——在指针前加上一个空方括号对. 方括号中的大小必须是整型,但不必是常量。也可以用一个表示数组类型的类型别名,来分配一个数组,这样,new表达式中就不需要方括号了:

void new_array()
{
    //定义数组类型
    typedef int array_type[10];
    //动态开辟数组空间
    int *p_array = new (array_type);
    delete[] p_array;
}

虽然我们通常称new T[]分配的内存为“动态数组”,但这种叫法某种程度上有些误导。 当用new分配一个数组时,我们并未得到一个数组类型的对象,而是得到一个数组元素类型的指针。 即使我们使用类型别名定义了一个数组类型,new也不会分配一个数组类型的对象。new返回的是一个元素类型的指针。 由于分配的内存并不是一个数组类型,因此不能对动态数组调用begin或end。 要记住我们所说的动态数组并不是数组类型,这是很重要的。 可以通过{}初始化动态数组

void new_array()
{
    //通过{}初始化动态数组
    int *p_array = new int[10]{1, 2, 3, 4};
    //释放动态数组
    delete[] p_array;
}

如果{}初始化列表小于数组长度,则默认补充空值,int补充0,string补充空字符串。 动态分配一个大小为0的数组是合法的

void new_array()
{
    int n = 0;
    //开辟一个大小为0的数组
    int *p_array = new int[n];
    for (int *p = p_array; p != n + p_array; p++)
    {
        cout << *p << " ";
    }

    delete[] p_array;
}

当n为0时,开辟了一个长度为0的动态数组,因为循环条件p != n+p_array,所以不会进入循环。 当我们用new分配一个大小为0的数组时,new返回一个合法的非空指针。此指针保证与new返回的其他任何指针都不相同。 对于零长度的数组来说,此指针就像尾后指针一样,我们可以像使用尾后迭代器一样使用这个指针。 可以用此指针进行比较操作,就像上面循环代码中那样。可以向此指针加上(或从此指针减去)0,也可以从此指针减去自身从而得到0。但此指针不能解引用——毕竟它不指向任何元素。

智能指针和动态数组

标准库提供了一个可以管理new分配的数组的unique_ptr版本。为了用一个unique_ptr管理动态数组,我们必须在对象类型后面跟一对空方括号:

void unique_array()
{
    //开辟一个20个整形的动态数组,用unique_ptr管理它。
    auto unarray = unique_ptr<int[]>(new int[20]);
    //释放这个动态数组
    unarray.release();
}

类型说明符中的方括号<int[]>指出up指向一个int数组而不是一个int。由于unarray指向一个数组,当unarray销毁它管理的指针时,会自动使用delete[]。 当一个unique_ptr指向一个数组时,我们可以使用下标运算符来访问数组中的元素:

void unique_array()
{
    //开辟一个20个整形的动态数组,用unique_ptr管理它。
    auto unarray = unique_ptr<int[]>(new int[20]);

    //可以通过下标访问数组元素
    for (size_t i = 0; i < 10; i++)
    {
        unarray[i] = 1024;
    }

    //释放这个动态数组
    unarray.release();
}

shared_ptr也可以管理动态数组,这一点在C++ primer 第5版里没有提及,但是我自己测试好用

void shared_array()
{
    // 开辟一个5个整形的动态数组,用shared_ptr管理它
    auto sharray = shared_ptr<int[]>(new int[5]{1, 2, 3, 4, 5});
    for (int i = 0; i < 5; i++)
    {
        cout << sharray[i] << " ";
    }
    sharray.reset();
    cout << endl;
}

C++ primer 第5版推荐的用法如下

void use_shared_array()
{
    shared_ptr<int> sharray = shared_ptr<int>(new int[5], [](int *p)
                                              { delete[] p; });
    sharray.reset();
}

上例中,shared_ptr管理一个动态数组并提供了删除器。

allocator类

当分配一大块内存时,我们通常计划在这块内存上按需构造对象。在此情况下,我们希望将内存分配和对象构造分离。这意味着我们可以分配大块内存,但只在真正需要时才真正执行对象创建操作(同时付出一定开销)。

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

void use_allocator()
{
    allocator<string> alloc;
    // allocator分配5个string类型对象的空间
    // 这些空间未构造
    auto const p = alloc.allocate(5);
    //销毁开辟的空间
    alloc.deallocate(p, 5);
}

上述代码用allocator构造alloc对象,说明开辟的空间是为string对象准备的,然后调用allocate开辟空间,但是这些空间不能直接使用,需要调用构造函数才能使用,我们用allocator类的construct来构造对象。

void use_allocator()
{
    allocator<string> alloc;
    // allocator分配5个string类型对象的空间
    // 这些空间未构造
    auto p = alloc.allocate(5);
    auto q = p;
    string str = "c";
    for (; q != p + 5; q++)
    {
        //构造字符串,每次字符串增加c字符
        alloc.construct(q, str);
        str += "c";
    }
    // //打印构造的字符串列表
    for (q = p; q != p + 5; q++)
    {
        cout << *q << endl;
    }

    //销毁开辟的空间
    alloc.deallocate(p, 5);
}

循环中通过construct为每个q指向的空间构造string对象,对象的内容就是str的内容,str会随着循环每次增加c,所以上面的代码输出如下

c
cc
ccc
cccc
ccccc

另外stl也提供了一些拷贝和填充内存的算法

void use_allocator()
{
    vector<int> ivec = {1, 2, 3, 4, 5};
    allocator<int> alloc;
    //开辟2倍ivec大小的空间
    auto p = alloc.allocate(ivec.size() * 2);
    //将ivec的内容copy至alloc开辟的空间里
    //返回q指向剩余未构造的内存空间的起始地址
    auto q = uninitialized_copy(ivec.begin(), ivec.end(), p);
    //将剩余元素初始化为42
    uninitialized_fill_n(q, ivec.size(), 42);
}

通过uninitialized_copy将ivec元素拷贝到p指向的空间,同样完成了构造。 uninitialized_fill_n将剩余ivec大小未构造的空间全部初始化为42。

总结

本文介绍了动态数组开辟的方法,利用new关键字可以开辟动态数组,利用delete[]可以回收数组。 也实现了通过shared_ptr和unique_ptr等智能指针管理动态数组的方案。 最后通过列举allocator的一些方法,展示了如何实现开辟空间和构造对象分离的方式动态构造对象。 源码连接 https://gitee.com/secondtonone1/cpplearn 想系统学习更多C++知识,可点击下方链接。 C++基础

results matching ""

    No results matching ""