funciones - Metaprogramación de plantillas C++: ¿es posible generar el código generado?

funciones en c

Question

Me gustaría depurar algún código de plantilla para entenderlo mejor.
Lamentablemente, soy nuevo en la metaprogramación de plantillas y ES difícil para mí entrar.

Cuando trato de generar los archivos fuente preprocesados ​​obtengo 125 000 líneas de código: /

Entonces, ¿hay alguna manera de ver el Código generado? (La biblioteca que estoy usando es SeqAn )

Answer 1

Esta es potencialmente la respuesta a su pregunta:

Herramienta de preprocesador de plantilla C ++

Parece haber satisfecho a la última persona que preguntó, ¡aunque no puedo imaginar por qué! El resultado de un compilador de C ++ en C suele ser bastante ilegible, ya que no pretende ser una ayuda para la comprensión, sino simplemente un tipo de lenguaje ensamblador portátil.

Answer 2

No, en general, no se puede hacer. Las plantillas son simplemente parte del lenguaje C ++, no son un preprocesador por separado, por lo que no generan código C ++.

La solución habitual es rociar su código con afirmaciones estáticas y otras pruebas para verificar que las plantillas correctas sean instanciadas de la manera correcta.

Una vez que empiezas a perderse en tu metaprogramación, este simple truco puede ayudarte a determinar qué tipo es realmente un parámetro de plantilla:

// given a variable t of an unknown type T
int*** i = t;

Cuando el compilador encuentre esto, imprimirá un mensaje de error simple y agradable, "No se puede convertir <long, detailed typename> to int ***", lo que le permite verificar fácilmente que el parámetro de la plantilla T es en realidad del tipo que usted creo que debería ser

Answer 3

No, no lo es. El preprocesador no tiene nada que ver con el procesamiento de plantillas, que realiza el compilador. Las plantillas no generan código C ++, como tampoco lo hace una llamada a función: son parte integral del lenguaje C ++.

Answer 4

Verifique mi publicación en la depuración de metaprogramas de plantilla C ++

Desde la página 6 puedes ver cómo funciona. Para fines específicos, no necesitará toda la cadena de herramientas, se puede hacer a mano.

He creado un complemento de Visual C ++ donde podría colocar puntos de interrupción, etc., pero era más una prueba de concepto que una herramienta para el uso diario.

Hemos estado trabajando en una interfaz gráfica que muestra todas las instancias, permite depuración y creación de perfiles. Lamentablemente, no podemos prometer ninguna fecha de publicación para esa herramienta, ya que lo hacemos en nuestro tiempo libre bastante limitado.

ACTUALIZACIÓN: el depurador y el perfilador están disponibles here

ACTUALIZACIÓN: C ++ ahora presentación

Answer 5

en general, no es posible generar el código completo. Pero lo que encontré extremadamente interesante, es la capacidad de usar el depurador de Visual C ++ para mostrarle el tipo. Toma ese meta-programa simple:

template<class Head, class Tail>
struct type_list
{
  typedef Head head;
  typedef Tail tail;
};

struct null_type
{};

template<class List>
struct list_head
{
  typedef typename List::head head;
};

template<class List>
struct list_tail
{
  typedef typename List::tail tail;
};

template<class List>
struct list_length
{
  static const size_t length = 1+list_length< typename list_tail<List>::tail >::length;
};

template<>
struct list_length<null_type>
{
  static const size_t length = 0;
};


int main()
{
  typedef 
    type_list
    < int
    , type_list
      < double
      , type_list
        < char
        , null_type
        >
      >
    >       my_types;

  my_types test1;

  size_t length=list_length<my_types>::length;

  list_head<list_tail<list_tail<my_types>::tail>::tail>::head test2;

}

Acabo de instanciar mis meta-tipos. Estas todavía son instancias de clase C ++ vacías que tienen al menos 1 byte de longitud. Ahora puedo poner un punto de interrupción después de la última instanciación de test2 y ver qué tipos / valores de longitud, test1 y test2 son de:

Esto es lo que muestra el depurador:

length  3   unsigned int
test1   {...}   type_list<int,type_list<double,type_list<char,null_type> > >
test2   -52 ''Ì'' char

Ahora que sabes que el jefe te devolvió un personaje, tu lista contiene int, double, char y termina con null_type.

Eso me ayudó mucho. A veces es necesario copiar el tipo realmente desordenado a un editor de texto y formatearlo en un formato legible, pero eso le da la posibilidad de rastrear lo que está dentro y cómo se calcula.

Espero que ayude,
Ovanes