Question

我的代码中有以下几行：

#define NUM_THREADS 8 // NUM_THREADS is variable

myClass myVar[NUM_THREADS] {{&A,&x}};

A和x只是myClass构造函数中用于设置myVar对象的某些变量大小的变量。但是，A和x的值直到运行时才知道。

由于NUM_THREADS是可变的，我想要的是每个对象（即myVar [NUM_THREADS-1：0]获取为构造函数发送的相同值，而不必手动输入以下内容。：

myClass myVar[NUM_THREADS] {{&A,&x},{&A,&x},{&A,&x},{&A,&x},{&A,&x},{&A,&x},{&A,&x},{&A,&x}};

这是构造函数的样子：

myClass::myClass(Aclass *A_orig, Xclass *x_orig) { 
  A_new = *A_orig;
  x_new = *x_orig;
}

Answer 1

您可以使用std::index_sequence在参数包中生成0到N的数字。我就是这样做的：

MyClass&& make_my_class(std::size_t, MyClass&& m) { return std::move(m); }

template<std::size_t... S>
void makeThreads(std::index_sequence<S...>) {
    std::array<MyClass, S> myVar{make_my_class(S, {&A,&x})...};
}

template<std::size_t N>
void makeThreads() {
    makeThreads(std::make_index_sequence<N>{});
}

现在，您可以像这样使用它：

constexpr std::size_t numberOfThreads = 8;

makeThreads<numberOfThreads>();

此解决方案的优点是生成的代码与您手动编写的代码完全相同。

此解决方案的一个缺点是您必须在编译时知道所需的线程数，而允许使用向量的解决方案在运行时确定大小。这是有道理的，因为你要求编译器为你填充大括号。对于编译器来说，它必须知道你希望它在数组初始化中重复的MyClass的数量。

Answer 2

我建议您使用std::vector：

std::vector<MyClass> v1(20, MyClass(&A,&x)); // Initialize a vector with 20 instances of MyClass.

Answer 3

创建数组并在循环中构造每个对象。

 $scope.refreshBornDistricts = function (item) {
     console.log(item);
 };

您首先默认构建对象，但这不一定是个问题。一个更好的解决方案可能是为这两个字段提供setter，并在循环中设置它们，如果你不介意它们是可变的。

但是，如果你支持它们，你可能应该使用myClass myVar[NUM_THREADS]; for(int i = 0; i < NUM_THREADS; ++i) myVar[i] = myClass(A, x);或std::vector。

Answer 4

如果不使用专用功能，我认为不可能。不过，您可以使用std::fill标题中的std::fill_n或algorithm进行测试。

以下是一个示例：

#include <iostream>
#include <algorithm>

class AClass
{
public:
  AClass() {}
  AClass(int a, int b) : a(a), b(b) {}

  int getA() { return a; }
  int getB() { return b; }
private:
  int a;
  int b;
};

int main()
{
  AClass aclass[8];
  std::fill_n(aclass, 8, AClass(1, 2));

  for (int i = 0; i < 8; ++i)
  {
      std::cout << aclass[i].getA() << aclass[i].getB() << "\n";
  }

  std::cin.get();
  return 0;
}

如何在构造函数中将对象数组初始化为相同的值？

4 个答案: