在 C++ 中，如何为动态对象数组中的所有对象调用参数化构造函数？

Question

当我定义对象的动态数组时，我想为数组中的所有对象选择一个参数化构造函数。不必像这样为每个对象编写所选的构造函数

#include <iostream>

using namespace std;


class foo {
public:
    foo ()
    { 
        cout << "default constructor" << endl;
    }


    foo (int x)
    {
        cout << "parameterized constructor " << endl;
    }

    ~foo ()
    {
        cout << "destructor" << endl;
    }
};


int main (void)
{
    int size = 3, parameter = 10;
    foo *array;
    array = new foo [size] { foo(parameter), foo(parameter), foo(parameter) };

    cout << endl;

    delete [] array;
    return 0;
}

输出

parameterized constructor 
parameterized constructor 
parameterized constructor 

destructor
destructor
destructor

因此，正如您从上面的代码中看到的，我可以为数组中的每个对象选择参数化构造函数array = new foo [size] { foo(parameter), foo(parameter), foo(parameter) };。但是，如果用户输入 size。同样的技巧不会奏效

当我搜索解决方案时，我发现我可以像这样使用复制构造函数来完成

#include <iostream>

using namespace std;


class foo {
public:
    foo ()
    { 
        cout << "default constructor" << endl;
    }


    foo (int x)
    {
        cout << "parameterized constructor " << endl;
    }

    ~foo ()
    {
        cout << "destructor" << endl;
    }
};


int main (void)
{
    int size = 3, parameter = 10;
    foo *array;
    array = new foo [size];

    cout << endl;

    for (int i = 0; i < size; i++)
        array[i] = foo(parameter);

    cout << endl;
    
    delete [] array;
    return 0;
}

输出

default constructor
default constructor
default constructor

parameterized constructor 
destructor
parameterized constructor 
destructor
parameterized constructor 
destructor

destructor
destructor
destructor

但是，每个对象都会调用析构函数，我不希望这样我只是想在第一次分配时这样做

在此先感谢，我希望有一个解决方案。

Answer 1

我会使用 for 循环 :

array = new foo [size];
for(int i = 0; i < size; i++) {
   array[i] = foo(parameter);
}

我没有看到更简单的方法。使用这种方法，您的 size 可以很容易地进行参数化。

对于您的“析构函数问题”，在 foo 上使用指针：

array = new *foo[size];
for(int i = 0; i < size; i++) {
   array[i] = new foo(parameter);
}

但不要忘记在需要时删除每个 foo 实例：

for(int i = 0; i < size i++) {
   delete array[i];
}
delete[] array;

Answer 2

这个问题最简单的解决方案是使用 std::vector 它在内部处理所有这些问题，例如：

#include <vector>
// skipping class declaration for brevity
int main (void)
{
    int size = 3, parameter = 10;
    std::vector<foo> array;
    array.reserve(size);

    cout << endl;

    for (int i = 0; i < size; i++)
        array.emplace_back(parameter);

    cout << endl;

    return 0;
}

但是，如果出于某种原因您 want/need 手动执行此操作，那么您应该分配一个“原始缓冲区”并在该缓冲区内构造带有放置 new 的对象 - 然而这也会要求您手动调用析构函数

一个可能的示例，“手动”执行所有操作可能如下所示

int main (void)
{
    int size = 3, parameter = 10;
    foo *array = reinterpret_cast<foo*>(new char[size * sizeof(foo)]);

    cout << endl;

    for (int i = 0; i < size; i++)
        new (&array[i]) foo(parameter);

    cout << endl;

    for (int i = 0; i < size; i++)
        array[i].~foo();

    delete[] reinterpret_cast<char*>(array);
    return 0;
}

一个可以说更简洁的解决方案是使用 std::allocator 和 std::allocator_traits - 这看起来像这样

#include <memory>
// skipping class declaration
int main (void)
{
    std::allocator<foo> alloc;
    using alloc_t = std::allocator_traits<decltype(alloc)>;
    int size = 3, parameter = 10;
    foo *array;
    array = alloc_t::allocate(alloc, size);

    cout << endl;

    for (int i = 0; i < size; i++)
        alloc_t::construct(alloc, &array[i], parameter);

    cout << endl;

    for (int i = 0; i < size; i++)
        alloc_t::destroy(alloc, &array[i]);
    
    alloc_t::deallocate(alloc, array, size);
    return 0;
}

在 C++ 中，如何为动态对象数组中的所有对象调用参数化构造函数？

How can i call the parameterized constructor for all objects in my dynamic array of objects on allocation in c++?

c++

arrays

copy-constructor

dynamic-arrays

parameterized-constructor