使用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協同工作，而不用其他任何測試。在規則方面可能不正確。