编译时将initializer_list<T>转换为initializer_list<vector<T>>

Question

我有一个类构造函数接受

initializer_list<T>

此构造函数必须运行接受

initializer_list<vector<T>>.

因此，我必须将初始化程序列表转换为2d初始化程序列表。

{1, 2, 3, 4} to { {1}, {2}, {3}, {4} }

编辑：

我有一个类构造函数接受

initializer_list<T>

此构造函数必须运行接受

initializer_list<array<T, 1>>.

因此，我必须将初始化程序列表转换为2d初始化程序列表。

{1, 2, 3, 4} to { {1}, {2}, {3}, {4} }

Answer 1

下面可以找到一个完整的示例，如果在构造函数中将类的<typename T>声明与<typename... Args>包混合仍有问题：

#include <iostream>
#include <array>
#include <utility>
#include <initializer_list>

template <typename T>
class A
{
public:
    A(std::initializer_list<std::array<T, 1>> i);

    virtual ~A() = default;
};

template <typename T>
A<T>::A(std::initializer_list<std::array<T, 1>> i)
{
    std::cout << i.size() << std::endl;
}

template <typename T>
class B : public A<T>
{
public:
    template <typename... Args>
    B(Args&&... args);
};

template <typename T>
template <typename... Args>
B<T>::B(Args&&... args) : A<T>{std::array<T, 1>{std::forward<Args>(args)}...}
{

}

int main()
{
    B<int> b{ 1, 2, 3, 4, 5, 6, 7 };
    return 0;
}

现场演示链接。

Answer 2

为什么不让您的子类接受参数包并将其转发给父构造函数呢？

struct Parent
{
    template<typename T>
    Parent(std::initializer_list<std::array<T, 1>>) { }

    virtual ~Parent() = default;
};

struct Child : Parent
{
    template<class... Args>
    Child(Args&&... args) : Parent{{{args}...}} { }
};

Answer 3

std::initializer_list<T>是一个奇怪的混合体:要创建一个，您需要静态地知道它的大小和内容，但是一旦您得到一个，您就不能静态地确定它的内容！换句话说，我认为您不能从一个std::initializer_list<std::vector<T>>创建一个std::initializer_list<T>。

您可以做的是获取一个可变参数列表，可能是约束，使所有相同的类型和类型都是整数的，然后从它构造一个std::initializer_list<std::vector<T>>：

template <typename T>
void g(std::initializer_list<T> list) { ... }

template <typename... T>
void f(T... args) {
    g({ std::array<T, 1>(args)... });
}