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

Question

I have the following lines in my code:

#define NUM_THREADS 8 // NUM_THREADS is variable

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

A and x are just variables that are used in the myClass constructor to setup the size of some variables of the myVar objects. However, the values of A and x aren't known until run time.

Since NUM_THREADS is variable, what I want is for every object (ie myVar[NUM_THREADS-1:0] to get the same values sent in for the constructor, without having to manually type out the following.:

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

Here's what the constructor looks like:

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

Answer 1

You can use std::index_sequence to generate numbers from 0 to N in a parameter pack. This is how I'd do it:

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>{});
}

Now, you can use it like that:

constexpr std::size_t numberOfThreads = 8;

makeThreads<numberOfThreads>();

The advantage of this solution is that the resulting code is exactly the same as if you'd wrote it by hand.

One disadvantage of this solution is that you have to know the number of thread you want at compile-time, whereas the solution using vectors is allowed to determine the size at runtime. It make sense, as you ask the compiler to fill the braces for you. For the compiler to do it, it has to know the number of MyClass you want it to repeat in the array initialization.

Answer 2

我建议你使用std::vector ：

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

Answer 3

Create the array and construct each of the objects in a loop.

myClass myVar[NUM_THREADS];
for(int i = 0; i < NUM_THREADS; ++i) myVar[i] = myClass(A, x);

You are default constructing objects first, but that isn't necessarily a problem. A better solution might be to provide setters for both of those fields and set them in the loop if you don't mind them being mutable .

---

Really, though, you should probably be using std::vector or std::array if you support them.

Answer 4

I do not think it is possible without using a dedicated function. However you can test with std::fill or std::fill_n from the algorithm header.

Here is a sample:

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