Question

我需要使用非默认构造函数创建一个对象数组。应该使用什么语言功能来实现这一目标？

这行代码不允许我这样做。

Object objects[10]{("foo", "bar")};

Answer 1

除非您想在初始化列表中指定所有单个对象，否则使用普通简单数组实际上不可能。

然而，使用std::vector它很简单，因为有一个constructor overload可以使用向量和的大小来初始化所有元素。所以你可以做类似

的事情

std::vector<Object> objects(10, Object("foo", "bar"));

以上将创建一个包含十个元素的向量，所有元素都初始化为Object("foo", "bar")的副本。

Answer 2

使用=并在初始化列表中传递非默认ctor的值。这样，您应该定义数组中的每个值。

Example

int main()
{
    struct A {
        int _v;

        A(int v) : _v(v) {}
    };

    A my_a[3] = {0, 1, 2};

    for (auto i : my_a)
      std::cout << i._v << ", ";
    std::cout << "\n";

}

Answer 3

简短的回答是没有办法用原始数组做到这一点。另一种方法是使用提供这种可能性的std::vector。

Answer 4

这样的东西？

#include <array>
#include <iostream>

struct foo {
    int a, b;
};

int main()
{
  std::array<foo, 4>  v= {{ {1, 2}, {2, 3}, {3, 4}, {4, 5} }};
  for (auto f : v) {
      std::cout << f.a << ' ' << f.b << std::endl;
  }
}

Answer 5

您可以在对象上使用向量或指针数组。

Object* arr[6];
for (int i = 0; i < 6; i++)
{
     arr[i] = new Object("angry dog", 6);
}

Answer 6

Using Double pointer（pointer to pointer concept）：指向一个指针的指针是多个间接的一种形式，或者是一个指针链。通常，指针包含变量的地址。当我们定义一个指向指针的指针时，第一个指针包含第二个指针的地址，第二个指针指向包含实际值的位置，如下所示。在这里，我们可以分配多个要分配的块，因此对于每个索引，我们必须使用 new 关键字调用参数化构造函数进行初始化

#include <iostream> 
#include <string>
#define N 5 
  
using namespace std; 
  
class Test { 
    // private variables 
    string x, y; 
  
public: 
    // parameterised constructor 
    Test(string x, string y) 
    { 
        this->x = x; 
        this->y = y; 
    } 
  
    // function to print 
    void print() 
    { 
        cout << x << " " << y << endl; 
    } 
}; 
  
int main() 
{ 
    // allocating array using 
    // pointer to pointer concept 
    Test** arr = new Test*[N]; 
  
    // calling constructor for each index 
    // of array using new keyword 
    for (int i = 0; i < N; i++) { 
        arr[i] = new Test(to_string(i), to_string(i + 1)); 
    } 
  
    // printing contents of array 
    for (int i = 0; i < N; i++) { 
        arr[i]->print(); 
    } 
  
    return 0; 
}

Answer 7

C++ 中的数组可能意味着不同的东西。 array 用于 C++11 中添加的固定大小的数组、对象 T[] 的原始数组（与 T* 相同）或向量。

array = { } 你可以显式地初始化每个对象，比如大括号内的string("ad")。
T* 或 T[] 你不能这样做，唯一的方法是用默认构造函数初始化。
T** 或 T*[]，您可以使用 T 的任何参数化构造函数进行初始化
vector 您可以使用 emplace(v.end(), args...) [可选地在循环中] 初始化为相同或可变的参数。这可能比 3 个更有效，因为 3 个对象可能分散在不同的内存位置。

以上列表可能不完整，可能有错误。目的是开启这个思路，欢迎大家指正和改进。

如何使用参数化构造函数创建对象数组

7 个答案: