typeswitch runtime per TypeList come un interruttore al posto di un nidificato se di?

Question

Questo è da TTL:

////////////////////////////////////////////////////////////
//  run-time type switch
template <typename L, int N = 0, bool Stop=(N==length<L>::value) > struct type_switch;

template <typename L, int N, bool Stop>
  struct type_switch
  {
    template< typename F >
      void operator()( size_t i, F& f )
      {
        if( i == N )
        {
          f.operator()<typename impl::get<L,N>::type>();
        }
        else
        {
          type_switch<L, N+1> next;
          next(i, f);
        }
      }
  };

E 'utilizzato per typeswitching su una TypeList. La domanda è - che stanno facendo questo attraverso una serie di nidificato se di. C'è un modo per fare questo tipo di switch come un unico istruzione select, invece?

Grazie!

Answer 1

Avrete bisogno del preprocessore per generare un grande switch. Avrete bisogno get<> al no-op ricerche out-of-bound. Controllare l'output del compilatore per essere sicuri che i casi non utilizzati producono nessun output, se vi interessa; regolare come necessario;. v)

Controlla la Boost preprocessore biblioteca se si cura di ottenere bravo in questo genere di cose ...

template <typename L>
  struct type_switch
  {
    template< typename F >
      void operator()( size_t i, F& f )
      {
        switch ( i ) {
         #define CASE_N( N ) \
         case (N): return f.operator()<typename impl::get<L,N>::type>();
         CASE_N(0)
         CASE_N(1)
         CASE_N(2)
         CASE_N(3) // ad nauseam.
      }
  };

Answer 2

Non penso così.

Questo tipo di modello metaprogrammazione avviene normalmente con la ricorsione. Dal momento che tutto accade al momento della compilazione, non sarei sorpreso se non c'è ricorsione fase di esecuzione o di condizione controlli.

Answer 3

Si può sempre usare una ricerca binaria, invece di una ricerca lineare. Sarebbe più complicato e più probabilità di avere bug in esso (ricerca binaria è sorprendentemente facile rovinare).

Si potrebbe anche espandere manualmente N type_switch::operator(), dove N è un po 'ragionevole limite superiore al numero di TypeList le lunghezze si avrà nel programma.