C/C++ Espansione macro e generazione codice

Question

Entrambe le espansioni Macro & Generazione codice hanno vantaggi &. Qual è il tuo approccio preferito e perché? Quando dovremmo scegliere l'uno rispetto all'altro? Si prega gentilmente di avvisare. Grazie!

espansione Macro può essere molto utile & utile: http://dtemplatelib.sourceforge.net/table.htm

vs

Mentre la generazione di codice ti dà un sacco di codice di bello: http://code.google.com/p/protobuf/ http://incubator.apache.org/thrift/

Answer 1

E 'un compromesso. Lasciatemi fare un esempio. Ho inciampato sulla tecnica di differential execution intorno al 1985 e penso che sia uno strumento davvero valido per la programmazione delle interfacce utente. In sostanza, ci vuole semplici programmi strutturati come questo:

void Foo(..args..){ 
    x = y; 
    if (..some test..){ 
    Bar(arg1, ...) 
    } 
    while(..another test..){ 
    ... 
    } 
    ... 
} 

e mucks con la struttura di controllo in questo modo:

void deFoo(..args..){ 
    if (mode & 1){x = y;} 
    {int svmode = mode; if (deIf(..some test..)){ 
    deBar(((mode & 1) arg1 : 0), ...) 
    } mode = svmode;} 
    {int svmode = mode; while(deIf(..another test..)){ 
    ... 
    } mode = svmode;} 
    ... 
} 

Ora, davvero un buon modo per farlo sarebbe stato quello di scrivere un parser per C o qualsiasi sia la lingua di base, quindi cammina l'albero di analisi, generando il codice che desidero. (Quando l'ho fatto in Lisp, quella parte era facile.)

Ma chi vuole scrivere un parser per C, C++ o altro?

Così, invece, ho solo scrivere delle macro in modo che io possa scrivere il codice in questo modo:

void deFoo(..args..){ 
    PROTECT(x = y); 
    IF(..some test..) 
    deBar(PROTECT(arg1), ...) 
    END 
    WHILE(..another test..) 
    ... 
    END 
    ... 
} 

Tuttavia, quando faccio questo in C#, qualcuno nella loro saggezza ha deciso macro erano male, e io don Non voglio scrivere un parser C#, quindi devo fare la generazione del codice a mano. Questo è un dolore reale, ma vale comunque la pena rispetto al solito modo di codificare queste cose.

Answer 2

in C o C++, macro espansione è notoriamente difficile da eseguire il debug. D'altra parte, scrivere un generatore di codice è più facile eseguire il debug perché è un programma separato di per sé.

Tuttavia, è necessario tenere presente che si tratta di una limitazione del preprocessore C. Ad esempio, nella famiglia di lingue Lisp, l'espansione macro è la generazione del codice, sono esattamente la stessa cosa. Per scrivere una macro, scrivi un programma (in Lisp) per trasformare l'input di S-expression in un'altra espressione S, che viene poi passata al compilatore.

Answer 3

Per C++ preferisco la metaprogrammazione del modello o la generazione del codice su macro, ma i macro hanno ancora i loro usi.

L'esempio che hai dato con dbtemplatelib potrebbe essere coperto con C++ 0x Variadic Templates, con ulteriori vantaggi, come il controllo di tipo ecc

Answer 4

Entrambi hanno i loro problemi. A differenza delle macro, la generazione del codice può produrre codice leggibile e debuggabile (è anche una parola?), Ma è meno flessibile e più difficile da modificare.