使用C++ 11 initializer_list用递归定义的类型使用constexpr

Question

是否可以使用C++ 11 initializer_list组装一递归定义类如Foo，下面，使用constexpr构造：

template <size_t N> 
struct Foo { 
    constexpr Foo(int x, Foo<N-1> f) : x(x), xs(xs) {} 
    int x; 
    Foo<N-1> xs; 
}; 

template <> struct Foo<0> {}; 

我可以初始化一个Foo<3>使用：

int main(int argc, char *argv[]) 
{ 
    Foo<3> a = Foo<3>(1,Foo<2>(2,Foo<1>(3,Foo<0>()))); 
    return 0; 
} 

这将是很好使用的Foo < 3> A = {1,2,3}代替。如果initializer_list中有constexpr tail函数，我认为它应该起作用。

Answer 1

是的，以一种四舍五入的方式，有效地将初始化程序列表打包并重新打包为更适合的格式。然而，有一个更好的（imho）方式：可变模板。

#include <stddef.h> 
#include <iostream> 

template <size_t N> 
struct Foo { 
    template<class... Tail> 
    constexpr Foo(int i, Tail... t) : x(i), xs(t...) {} 

    void print(){ 
    std::cout << "(" << x << ", "; 
    xs.print(); 
    std::cout << ")"; 
    } 

    int x; 
    Foo<N-1> xs; 
}; 

template <> 
struct Foo<1> { 
    constexpr Foo(int i) : x(i) {} 
    void print(){ std::cout << "(" << x << ")"; } 
    int x; 
}; 

int main(){ 
Foo<3> x = {1, 2, 3}; 
x.print(); 
std::cout << "\n"; 
} 

输出按预期：

（1，（2，（3）））

注意，我选择1作为碱的情况下，因为它简单地更有意义。

Answer 2

我没有编译器，可以编译它，但我认为正确的答案是沿着线的东西：

template <size_t N> 
struct Foo { 
    constexpr Foo(int x, Foo<N-1> f) //template iterator constructor 
    : x(x), xs(xs) {} 
    Foo(std::initializer_list<int> f) //initializer list constructor 
    : x(*f.begin()), xs(++f.begin(), f.end()) 
    { static_assert(xs.size()==N, "incorrect number of values in initializer list");} 
    template<class iter> 
    Foo(iter first, iter last) //template iterator constructor 
    : x(*first), xs(++first, last) {} //UB if wrong number of values given 

    int x; 
    Foo<N-1> xs; 
}; 

template <> 
struct Foo<1> { //I use 1 for smaller structures 
    constexpr Foo(int f) 
    : x(f) {} 
    Foo(std::initializer_list<int> f) 
    : x(*f.begin()) 
    { static_assert(xs.size()==1, "incorrect number of values in initializer list");} 
    template<class iter> 
    Foo(iter first, iter last) 
    : x(*first) 
    { assert(first+1 == last); } 

    int x; 
}; 

对于一个递归结构，初始化列表必须传递给递归地使用迭代器的构造函数。

Answer 3

的解决方案是让一个函数调用

template<class T> 
constexpr T initlist_val(initializer_list<T>& list, int index) { 
    return (index < list.size()) ? *(list.begin() + index) : 0; 
} 

现在你可以去

class MyClass { 
public: 
    int A, int B; 
    constexpr MyClass(const initializer_list<int>& list) : A(initlist_val(list,0)), B(initlist_val(1)) { 
    // Put nothing here etc.. 
    } 

}; 

你不需要所有其他的东西。这可以与GCC协同工作，而不用其他任何测试。在规则方面可能不正确。