Tiempo de ejecución de typeswitch TypeListas como un interruptor en lugar de un anidado si de?

Question

Esto es de 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);
        }
      }
  };

Se utiliza para typeswitching en un TypeLista. La pregunta es - que están haciendo esto a través de una serie de anidado si '. ¿Hay una manera de hacer este interruptor tipo como una sola instrucción de selección en su lugar?

Gracias!

Answer 1

Usted necesitará el preprocesador para generar un gran switch. Tendrá que get<> a no-op búsquedas fuera de atado. Compruebe la salida del compilador para asegurarse de casos no utilizados producen ninguna salida, si usted se preocupa; ajustar según sea necesario;. v)

Salida del preprocesador Boost biblioteca si es que quiere ser bueno en este tipo de cosas ...

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

Yo no lo creo.

Este tipo de metaprogramming plantilla se realiza normalmente con la recursividad. Puesto que todo sucede en tiempo de compilación, no me sorprendería si no hay recursividad tiempo de ejecución o condición de cheques.

Answer 3

Siempre se puede utilizar una búsqueda binaria en lugar de una búsqueda lineal. Sería más complicado y más propensos a tener fallos en el mismo (búsqueda binaria es sorprendentemente fácil echar a perder).

También puede ampliar manualmente N type_switch::operator(), donde N es un poco razonable límite superior del número de longitudes typelist que tendrá en su programa.