数量未知（“模板化”）的类的初始化程序列表 [英] Initializer list for an unknown ("templated") amount of classes

问题描述

如果我有一个类模板，其中包含一个带有另一个类的数组，且该类的类型具有未定义的字段数量（数量是模板参数），那么如何运行其构造函数（如果它们带有参数）？

If I have a class template which contains an array with another class as type with undefined amount of fields (the amount is a template parameter), how do I run their constructors (if they take parameters)?

下面是一些示例代码：

class ArrayClass
{
public:
    ArrayClass() = delete;
    ArrayClass(int anyParameter) {}
};

template <const int amountOfFields>
class ContainingClass
{
    ArrayClass myArray[amountOfFields];

public:
    ContainingClass();
};

template <const int amountOfFields>
ContainingClass<amountOfFields>::ContainingClass()
    :
    myArray(5)     // doesn't work of cause
{}

是否可以给每个ArrayClass，无论有多少个，相同的参数（或不同的参数）？ （我基本上不需要它，但它会让我更轻松）。

Is it possible to give every ArrayClass, no matter how many there are, the same parameter (or different ones)? (I don't essentially need it but it would make things easier for me)

推荐答案

在GCC 8.1中对我有用/ Clang 6.0和C ++ 14，尽管我不确定是否符合标准：

This work for me with GCC 8.1 / Clang 6.0 and C++14, though I am definitely not sure whether it is Standard compliant:

class E {
public:
   E() = delete;
   E(int i) : i_(i) { }
   operator int() const { return i_; }
private: 
   int i_;
};

template <typename T>
T dummy(T val, /* [[maybe_unused]] */ size_t I) { return val; }

template <typename T, size_t... I, typename U>
constexpr auto make_array_impl(U val, std::index_sequence<I...> is) {
   return std::array<T, is.size()>{dummy(val, I)...};
}

template <typename T, size_t N, typename U>
constexpr auto make_array(U val) {
   return make_array_impl<T>(val, std::make_index_sequence<N>{});
}

template <typename T, size_t N>
class A {
public: 
   A(T val) : a_{make_array<T, N>(val)} { }
   void print() { for (auto e : a_) std::cout << e << std::endl; }
private:
   std::array<T, N> a_;
};

int main() {
   A<E, 5> a(-1);    
   a.print();
}

实时演示： https://wandbox.org/permlink/Db9Zpf6gUMvg4MER

更新了更通用的解决方案：

Updated more generic solution:

template <typename T, size_t... I, typename... Args>
constexpr auto make_array_impl(std::index_sequence<I...> is, Args&&... args) {
   return std::array<T, is.size()>{ (I, T(std::forward<Args>(args)...))... };
}

template <typename T, size_t N, typename... Args>
constexpr auto make_array(Args&&... args) {
   return make_array_impl<T>(std::make_index_sequence<N>{}, std::forward<Args>(args)...);
}

这篇关于数量未知（“模板化”）的类的初始化程序列表的文章就介绍到这了，希望我们推荐的答案对大家有所帮助，也希望大家多多支持IT屋！