Tôi làm cách nào để có được một loại cụ thể từ gói loại variadic?

Question

Tôi muốn làm một cái gì đó như thế này:

template<typename ...T> struct foo 
{ 
    bar<0 /*to index through types in pack*/ ,T...>::type var1; 
    bar<1 /*to index through types in pack*/ ,T...>::type var2; 
    ... 
} 

Nhưng làm thế nào tôi sẽ xác định bar? Không có kỹ thuật đệ quy nào đến với tâm trí để làm điều này.

Tôi muốn có một kỹ thuật chung để tôi có thể nhập bất kỳ loại cụ thể nào từ gói loại, không chỉ hai loại được hiển thị trong ví dụ.

Answer 1

#include <iostream> 
#include <typeinfo> 

template<class T, class T2, class... Args> 
class C 
{ 
public: 
    typedef T type1; 
    typedef T2 type2; 
}; 

int main() 
{ 
    typedef C<int, double, int, float> c; 
    std::cout << typeid(c::type1).name() << " " << typeid(c::type2).name() << std::endl; 
} 

hoặc mb một cái gì đó như thế này.

#include <iostream> 
#include <typeinfo> 

template<int N, class T, class... Args> 
struct expand 
{ 
public: 
    typedef typename expand<N - 1, Args...>::type type; 
}; 

template<class T, class... Args> 
struct expand<1, T, Args...> 
{ 
public: 
    typedef T type; 
}; 

template<class... Args> 
class argsExpander 
{ 
public: 
    typedef typename expand<1, Args...>::type type1; 
    typedef typename expand<2, Args...>::type type2; 
}; 

template<class... Args> 
class C 
{ 
public: 
    typename argsExpander<Args...>::type1 var1; 
    typename argsExpander<Args...>::type2 var2; 
}; 

int main() 
{ 
    C<int, double, int, float> c; 
    std::cout << typeid(c.var1).name() << " " << typeid(c.var2).name() << std::endl; 
} 

http://liveworkspace.org/code/7de289f128e86eb6006f576cbaf98991

Answer 2

Vâng, bạn có thể làm điều này với đệ quy ... trên thực tế bạn có nhiều hoặc ít hơn được triển khai lại std::tuple (và ngầm std::get).

Công việc khó khăn đến khi truy cập các thành viên, vì bạn không thể gọi cho họ var1, var2, trừ khi bạn đặt tên chúng theo cách thủ công.

template <typename... TypeList> struct foo; 

template <typename Head, typename... Tail> 
struct foo<Head, Tail...>: public foo<Tail...> 
{ 
    Head var; 
}; 

Tôi đã sử dụng thừa kế ở đây, nhưng thành phần (sử dụng thành viên foo<Tail...> tail) hoạt động là tốt.

Bây giờ, nếu loại của bạn là duy nhất, bạn có thể truy cập vào các thành viên theo loại ...

// this overload if VarType is the first 
template <typename VarType, typename... FooTail> 
VarType& foo_get(foo<VarType, FooTail...>& f) 
{ 
    return f.var; 
} 

// this overload to walk down to foo's parent 
template <typename VarType, typename FooHead, typename... FooTail> 
VarType& foo_get(foo<FooHead, FooTail...>& foo) 
{ 
    return foo_get<VarType>(static_cast<foo<FooTail...>>(f)); 
} 

// call like: 
// int &x = foo_get<int>(my_foo_object); 

hoặc bạn có thể truy cập bằng cách vị trí:

template <int N, typename... TypeList> struct GetHelper; 

template <typename Head, typename... Tail> 
struct GetHelper<0, Head, Tail...> 
{ 
    static Head& get(foo<Head, Tail...> &f) { return f.var; } 
}; 

template <int N, typename Head, typename... Tail> 
struct GetHelper<N, Head, Tail...>: public GetHelper<N-1, Tail...> 
{}; 

template <int N, typename... TypeList> 
auto foo_get(foo<TypeList...> &f) 
    -> GetHelper<N, TypeList...>::get(*static_cast<foo<TypeList...>*>(0)) 
{ 
    return GetHelper<N, TypeList...>::get(f) 
} 

// call like: 
// int &x = foo_get<2>(my_foo_object); 

cả những có thể được cải thiện để nhận được báo cáo lỗi tốt hơn (và mặc dù tôi đã sử dụng cả hai kỹ thuật, tôi thậm chí không cố gắng biên dịch mã mẫu này)

Answer 3

Nếu tôi hiểu câu hỏi của bạn một cách chính xác, bạn muốn thực hiện điều gì đó tương tự o std :: tuple:

Tôi nghĩ rằng tuple được thực hiện theo cách này:

template <class T> 
class tuple 
{ 
    T mem; 
}; 

template <class T, class... REST> 
class tuple : tuple<REST...> 
{ 
    T mem; 
}; 

Answer 4

Đơn giản chỉ cần sử dụng std :: tuple như @Xeo tiếp tục cho ý kiến. Nó thuận tiện và thực hiện chính xác những gì bạn cố gắng làm.

Trích:

Tại sao không chỉ cần sử dụng một std::tuple<T...>?

yếu tố Access std::get<I>(tup) và

loại như std::tuple_element<I, std::tuple<T...>>::type