Newsgroup: it.comp.lang.c++
Titolo: preprocessore C++

ciao a tutti, vorrei porre un quesito parzialmente IT al NG
E' possibile scrivere Macro ricorsive ? N.B. non macro che 
generano codice sorgente ricorsivo, ma ricorsive in sé stesse 
(ossia la ricorsione deve essere "vista e gestita" a livello di 
preprocessing, non di compilazione. Io non ho trovato alcun 
costrutto di controllo macro abilitato all'interno della macro 
stessa, poiché se tento di usare costrutti condizionali #if, 
#else #elif  etc etc come condizioni di uscita, il preprocessore 
non riconosce che il segno cancelletto fa parte di una direttiva 
macro annidata, ma si aspetta di ricevere un parametro formale 
su cui fare lo "stringizing" (che non è ciò che mi serve).
In alternativa (uso MS Visual CPP 6.0 e non ho .NET), è 
possibile invocare il preprocessore standalone, o altrimenti 
arrestare l'elaborazione a valle del preprocessore interno ma 
prima che l'output venga inviato al compilatore, ovviamente 
salvando il risultato intermedio di testo sorgente ESPANSO ?
Infine, se tutto ciò è impossibile, esiste qualche preprocessore 
standalone per il CPP standard ansi in rete ?
grazie in anticipo a chiunque possa darmi qualche dritta
ciao
Soviet-Mario

 
Non so come mai tu abbia bisogno di usare il preprocessore con macro 
ricorsive, hai provato a valutare la metaprogrammazione template?
(E' moooolto più potente).
Alessandro

 "stringizing" (che non è ciò che mi serve).
Cosa devi fare? E' possibile, a seconda di quello che devi fare, che la 
soluzione piu' adeguata sia l'uso di templates:
<CODE>
#include<iostream>
template<int n> struct Factorial{
      static const int val = n * Factorial<n-1>::val;
};
template<> struct Factorial<0>{
      static const int val = 1;
};
int main()
{
      unsigned char array[Factorial<7>::val] = {0};
      std::cout << sizeof(array) << std::endl;
      return 0;
}
</CODE>
<OUTPUT>
5040
</OUTPUT>
Ad esempio guardati questo codice.
La dimostrazione che il fattoriale di 7 (espresso in modo ricorsivo) non 
venga calcolato at-run-time e' il fatto che lo uso come dimensione di un 
array di unsigned chars. Ovviamente pero', con i templates, la ricorsione 
viene gestita a livello di compilazione e non di pre-processore come tu 
richiedevi. Tuttavia la ricorsione non viene gestita a run-time e penso 
fosse a questo che tu ti riferissi realmente.
Se questa roba e' quello che ti interessa ti consiglio di comprare:
C++ Templates: The Complete Guide
David Vandevoorde, Nicolai M. Josuttis, David Vandervoorde
http://www.amazon.co.uk/exec/obidos/ASIN/0201734842/qid=1111442563/sr=8-1/ref=sr_8_xs_ap_i1_xgl/202-3122040-2964614
E' un libro di 500 pagine solo sui templates, Magari prima assicurati di 
avere le basi per questa lettura.
Tommaso Galleri

 fosse a questo che tu ti riferissi realmente.
il casino è che non ho trovato un modo per templare con una 
lista variabile di parametri. Temo non si possa fare, per la 
verità, ma prima le tento tutte
ciao e grazie delle risposte. SE ti vengono ulteriori idee, sono 
benvenute
CCCP++Mario


 verità, ma prima le tento tutte
Sì, si può fare... usando le Typelist della libreria Loki:
http://sourceforge.net/projects/loki-lib/
Non so se ci siano documentazione e/o esempi allegati oppure se 
ci sia qualcosa nel sito dello sviluppatore:
http://www.moderncppdesign.com/
Se non trovi nulla ti posso fare qualche esempio di utilizzo...
Ciao.
-- 
BSD is for UNIX lovers -- linux is for Windows haters.

"Soviet_Mario" <Sov...@MIR.CCCP> ha scritto nel messaggio 
news:fpA%d.4168$IN.1...@twister2.libero.it...

Ciao non so se può esserti utile ma mi pare che il codewarrior 
(compialtore ) espandeva le macro e ti faceva vedere come diventavano... (è 
da tanto che non lo uso quindi non posso dire altro)
Buon Lavoro Ciao 

In effetti la libreria Boost.Preprocessor e' spesso utilizzata per
gestire questo tipo di situazioni.
Un'alternativa completamente diversa e' passare un unico parametro di
tipo Boost.Tuple ed operarci sopra tramite l'accesso alle componenti
head e tail. Questo introduce la complessita' di dover impacchettare e
spacchettare gli argomenti in una tupla, ma ti consentirebbe di avere
un unico template al posto di tutti quelli generati tramite macro e di
avere codice piu' facile da debuggare. In ogni caso spulciati la
documentazione su 
www.boost.org
 .
Ciao,
Nicola

GRAZIE mille a tutti quelli che mi han dato delle dritte.
Ciao
Soviet_Mario