我如何为 c++ 中分配的动态对象数组中的所有对象调用参数化构造函数？

Question

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

#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;
}

output

parameterized constructor 
parameterized constructor 
parameterized constructor 

destructor
destructor
destructor

因此，正如您从上面的代码中看到的，我可以为数组中的每个 object 选择参数化构造函数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;
}

output

default constructor
default constructor
default constructor

parameterized constructor 
destructor
parameterized constructor 
destructor
parameterized constructor 
destructor

destructor
destructor
destructor

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

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

Answer 1

这个问题最简单的解决方案是使用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;
}

但是，如果出于某种原因您想要/需要手动执行此操作，那么您应该分配一个“原始缓冲区”并在该缓冲区内构造带有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;
}

Answer 2

我会使用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;