c++ - que - Tipos de tiempo de ejecución para las listas de tipos como un interruptor en lugar de un if anidado?

que es if else en programacion

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 usa para el cambio de tipos en una TypeList. La pregunta es: lo hacen a través de una serie de if anidados. ¿Hay alguna manera de hacer este cambio de tipo como una sola instrucción de selección en su lugar?

¡Gracias!

Answer 1

Necesitarás el preprocesador para generar un gran switch . Necesitará get<> para consultas fuera de límite no operativas. Compruebe la salida del compilador para asegurarse de que los casos no utilizados no produzcan ningún resultado, si le importa; ajustar según sea necesario; v).

Consulte la Biblioteca de preprocesadores de Boost si le interesa 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

No lo creo.

Este tipo de metaprogramación de plantillas normalmente se realiza con recursión. Como todo sucede en tiempo de compilación, no me sorprendería si no hay recursión en tiempo de ejecución o verificaciones de estado.

Answer 3

Siempre puede usar una búsqueda binaria en lugar de una búsqueda lineal. Sería más complicado y más probable que tenga errores (la búsqueda binaria es sorprendentemente fácil de estropear).

También puede expandir manualmente N type_switch::operator() , donde N es un límite superior razonable en el número de longitudes de lista de tipos que tendrá en su programa.