test se un tipo V è uno dei tipi di una tupla <...> senza variardics

Question

Una tipica implementazione sarebbe in questo modo:

template <typename V, typename T> 
struct Is_in_tuple; 

template <typename V, typename T0, typename... T> 
struct Is_in_tuple <V, tuple<T0, T...> > 
{ 
    static const bool value = Is_in_tuple<V, tuple<T...> >::value; 
}; 

template <typename V, typename... T> 
struct Is_in_tuple <V, tuple<V, T...> > 
{ 
    static const bool value = true; 
}; 

template <typename V> 
struct Is_in_tuple <V, tuple<> > 
{ 
    static const bool value = false; 
}; 

Il problema si pone in VS2012 cui esistono tuple, ma templates variadic non!

C'è una soluzione alternativa, un modo per eseguire tali test senza modelli variadic?

Answer 1

Purtroppo, non posso testarlo su MSVC2012 adesso.

#include <type_traits> 
#include <tuple> 

template<class Needle, class Haystack, int N = std::tuple_size<Haystack>::value> 
struct is_any_of 
    : std::integral_constant 
     < 
      bool, 
      (std::is_same<Needle, typename std::tuple_element<N-1, Haystack>::type> 
      ::value 
      || is_any_of<Needle, Haystack, N-1>::value) 
     > 
{}; 

template<class Needle, class Haystack> 
struct is_any_of<Needle, Haystack, 0> 
    : std::false_type 
{}; 

#include <iostream> 
int main() 
{ 
    typedef std::tuple<int, int, char, int, int> t0; 
    typedef std::tuple<int, int, int, int, int> t1; 

    std::cout << std::boolalpha << is_any_of<char, t0>::value << "\n"; 
    std::cout << std::boolalpha << is_any_of<char, t1>::value << "\n"; 
} 

Answer 2

Se VS2012 supporta tuple_size e tuple_element, si possono usare al posto (codice completamente non testato):

template <typename V, typename T, size_t T_end = std::tuple_size<T>::value> 
struct Is_in_tuple 
    : std::conditional<std::is_same<V, typename std::tuple_element<T_end-1,T>::type>::value, 
        std::true_type, Is_in_tuple<V, T, T_end - 1>>::type {}; 

template <typename V, typename T> 
struct Is_in_tuple <V, T, 0> : std::false_type {}; 

Answer 3

Un approccio completamente diverso si basa sul limite di dimensioni.

Contiamo sul numero massimo di argomenti, che è da 5 a 10 se ricordo correttamente.

Scriviamo una specializzazione per ogni dimensione oltre a 0 e 1 che invoca tuple di dimensioni più piccole (metà, per ricorsione minima), || il risultato di ciascuna metà.

Quindi scriviamo le specializzazioni <T> e <>.

Ripiega su questo se le altre soluzioni falliscono, poiché smette di funzionare nel momento in cui ottieni una tupla conforme agli standard, o addirittura cambia il simbolo del preprocessore del numero massimo di elementi per una tupla.