Einen Typ aus einer Vorlagenklasse extrahieren

Question

Ich implementiere einen Typ Extraktor extract_type<Class, nth-type> für jede Vorlagenklasse. Eine Beispielverwendung ist wie folgt dargestellt:

template <int, short, float, double, char> class C; 

extract_type<C, 0>::type => int 
extract_type<C, 1>::type => short 
extract_type<C, 2>::type => float 
extract_type<C, 3>::type => double 
extract_type<C, 4>::type => char 

Hier ist meine Implementierung.

// extract_type: recursive definition. 
template <template <typename...> class C, size_t idx, typename T, typename... RestT> 
struct extract_type; 

// extract_type: base 
template <template <typename...> class C, typename T, typename... RestT> 
struct extract_type< C<RestT...>, 0, RestT... > { 
    using type = T; 
}; 


// extract_type: recursive definition. 
template <template <typename...> class C, size_t idx, typename T, typename... RestT> 
struct extract_type : public extract_type< C<RestT...>, idx-1, RestT... > { 
}; 

jedoch der Compiler beschwert sich über

Typ/Wert Mismatch bei Argument 1 in Vorlage Parameterliste für ‚Template-Klasse C, lange unsigned int idx, Klasse T, Klasse ... RestT> struct Open :: extract_type‘ struct extract_type < ungültig, 0, RestT ...>

Wie kann ich dieses Problem gelöst werden?

Answer 1

Meinst du sowas (minimales, funktionierendes Beispiel)?

#include<tuple> 
#include<iostream> 
#include<type_traits> 

template<int, typename...> 
struct extract_type; 

template<int N, typename T, typename... O, template<typename...> typename U> 
struct extract_type<N, U<T, O...>>: extract_type<N-1, U<O...>> { }; 

template<typename T, typename... O, template<typename...> typename U> 
struct extract_type<0, U<T, O...>> { using type = T; }; 

int main() { 
    using MyTuple = std::tuple<int, double, char>; 
    // true 
    std::cout << std::is_same<extract_type<1, MyTuple>::type, double>::value << std::endl; 
    // false 
    std::cout << std::is_same<extract_type<2, MyTuple>::type, double>::value << std::endl; 
} 

Dieses würde Ihr Code (feste und Arbeitsversion) sein statt:

#include<tuple> 
#include<iostream> 
#include<type_traits> 

// extract_type: recursive definition. 
template <template <typename...> class C, size_t idx, typename T, typename... RestT> 
struct extract_type; 

// extract_type: base 
template <template <typename...> class C, typename T, typename... RestT> 
struct extract_type< C, 0, T, RestT... > { 
    using type = T; 
}; 

// extract_type: recursive definition. 
template <template <typename...> class C, size_t idx, typename T, typename... RestT> 
struct extract_type : public extract_type< C, idx-1, RestT... > { }; 

int main() { 
    // true 
    std::cout << std::is_same<extract_type<std::tuple, 1, int, double, char>::type, double>::value << std::endl; 
    // false 
    std::cout << std::is_same<extract_type<std::tuple, 2, int, double, char>::type, double>::value << std::endl; 
} 

ziemlich hässlich, ist es nicht?

Das Problem besteht darin, dass Sie es definieren, als ob die Vorlagenklasse getrennt von seinen Parametern übergeben werden soll, so dass die erste keine Rolle innerhalb extract_type hat.
Es bedeutet, dass Sie es definiert haben könnte als:

template <size_t idx, typename T, typename... RestT> 
struct extract_type; 

So wäre es wie verwendet:

extract_type<1, int, double, char>::type 

Mit dem gleichen Ergebnis: double.

Haben Sie den Fehler in Ihrem Beispiel (abgesehen von der syntaktischen natürlich)?

Answer 2

Hier ist meine Implementierung.

#include "iostream" 

template<class ...Ts> struct C {}; 

template<int N, class ...Ts> 
struct extract_type_impl; 

template<class C, int N> 
struct extract_type; 

template<template<class ...> class C, class ...Ts, int N> 
struct extract_type<C<Ts...>, N> { 
    typedef typename extract_type_impl<N, Ts...>::type type; 
}; 

template<int N, class T, class ...Ts> 
struct extract_type_impl<N, T, Ts...> { 
    typedef typename extract_type_impl<N - 1, Ts...>::type type; 
}; 

template<class T, class ...Ts> 
struct extract_type_impl<0, T, Ts...> { 
    typedef T type; 
}; 

int main() { 
    static_assert(std::is_same<extract_type<C<int, float, char, double>, 3>::type, double>::value, ""); 
    // static_assert(std::is_same<extract_type<C<int, float, char, double>, 3>::type, int>::value, ""); 
} 

• die Parameterlisten von C
• holen n-te Parameter

Live Demo