我怎么能调用参数化构造函数的所有对象在我的动态数组对象分配在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

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