Modello C++ Metaprogrammazione - È possibile generare il codice generato?

Question

Vorrei eseguire il debug di un codice basato su modelli per comprenderlo meglio.
Purtroppo Sono nuovo di modello metaprogrammazione ed è difficile per me arrivare in

Quando cerco di uscita i file di origine preprocessati ottengo 125 000 righe di codice:./

è così c'è un modo in cui posso vedere il codice generato? (La libreria che sto utilizzando è SeqAn)

Answer 1

No, non lo è. Il preprocessore non ha nulla a che fare con l'elaborazione dei template, che viene eseguita dal compilatore. I template non generano codice C++, più di quanto non faccia una chiamata di funzione - sono parte integrante del linguaggio C++ stesso.

Answer 2

Questo è potenzialmente la risposta alla tua domanda:

C++ Template preprocessor tool

sembra aver soddisfatto l'ultima persona che ha chiesto - anche se non riesco a immaginare perché! L'output di un compilatore C++ in C è in genere piuttosto illeggibile, perché non è inteso come aiuto alla comprensione, ma solo una sorta di linguaggio assembly portatile.

Answer 3

in generale non è possibile stampare l'intero codice. Ma quello che ho trovato estremamente interessante, è la possibilità di usare il debugger di Visual C++ per mostrarti il ​​tipo. Prendi questo semplice meta-programma:

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; 

} 

Ho appena creato un'istanza dei miei meta-tipi. Queste sono istanze di classe C++ ancora vuote che hanno una lunghezza di almeno 1 byte. Ora posso mettere un punto di interruzione dopo l'ultima istanza di test2 e vedere, quali tipi/valori di lunghezza, test1 e test2 sono di:

Ecco ciò che il debugger mostra:

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

Ora si conosce il head ti ha restituito un carattere, la tua lista contiene int, double, char e termina con null_type.

Questo mi ha aiutato molto. A volte è necessario copiare il tipo veramente disordinato in un editor di testo e formattarlo in un formato leggibile, ma ciò ti dà la possibilità di rintracciare ciò che è dentro e come viene calcolato.

Speranza che aiuta,
Ovanes

Answer 4

No, in generale, non può essere fatto. I template sono semplicemente parte del linguaggio C++, non sono un preprocessore separato, quindi non generano codice C++.

La solita soluzione consiste nel cospargere il codice con affermazioni statiche e altri test per verificare che i modelli giusti vengano istanziati nei giusti modi.

Una volta che si inizia a perdersi nel vostro metaprogrammazione, questo semplice trucco può aiutare a determinare quale tipo un parametro di modello è davvero:

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

Quando il compilatore incontra questo, sarà stampare una piacevole e semplice messaggio di errore, "Impossibile convertire <long, detailed typename> in int ***", consentendo di verificare facilmente che il parametro modello T sia effettivamente il tipo che si ritiene dovrebbe essere.

Answer 5

check my publication on C++ template metaprogram debugging

Da pagina 6 si può vedere come funziona. Per scopi specifici non avrai bisogno dell'intera toolchain, può essere fatto a mano.

ho messo insieme un Visual C++ aggiuntivo in cui è possibile inserire punti di interruzione ecc ma era piuttosto una prova di concetto che uno strumento per un utilizzo quotidiano.

Abbiamo lavorato su un frontend grafico che mostra tutte le istanze, permette il debug, profiling. Purtroppo non possiamo promettere alcuna data di pubblicazione per questo strumento, poiché lo facciamo nel nostro tempo libero piuttosto limitato.

UPDATE: il debugger e profiler è disponibile here

UPDATE: C++Now presentation