Newsgroup: it.comp.lang.c++
Titolo: Preprocessore

Nell'esempio che mi riporta il testo che sto leggendo ora, (capitolo
preprocessore paragrafo compilazione condizionale) non capisco come dovrei
capire la logica condizionale del preprocessore con questo codice:
/*  Determinazione delle soluzioni dell'equazione:
    a*x*x+b*x+c=0   */
#include <iostream.h>
#include <math.h>
#define TEST 1
int main()
{
    double root1, root2, a, b, c, root;
    cout<<"Inserisci i tre coefficienti a, b, c: ";
    cin>>a>>b>>c;
    clrscr();
    #if TEST
        double temp=b*b-4.0*a*c;
        cout<<"temp="<<temp<<"\n";
        root=sqrt(temp);
        cout<<"radice quadrata di temp="<<sqrt(temp)<<"n";
    #else
        root=sqrt(b*b-4*a*c);
    #endif
    root1=0.5*(root-b)/a;
    root2=-0.5*(root+b)/a;
    cout<<"Le soluzioni sono:\t"<<root1<<" e "<<root2<<"\n";
        return(0);
}
Il testo mi dice che viene valutata la condizione TEST, se questa è 1 allora
la porzione di codice che segue viene inclusa, se è zero non viene inclusa.
TEST però viene definita come costante uguale a 1, quindi questo codice
includerà sempre e solo la porzione della condizione if o sbaglio? Vi sono
casi in cui questa non viene inclusa e viene inclusa la porzione seguente
else?
Inoltre tra le due porzioni ai fini del calcolo di root non trovo nessuna
differenza, se non l'introduzione della variabile temp che ai fini del
calcolo delle due radici non cambia nulla!
Se qualcuno ha capito il senso di questo esempio, dove vuole arrivare
l'autore, me lo può gentilmente spiegare?
Ringrazio in anticipo per le risposte.    Ciao :-)

l'autore, me lo può gentilmente spiegare?
Si tratta sostanzialmente di "compilazione condizionale".
Cioe' il compilatore non produce in output la trasformazione di tutto
il codice sorgente, ma solo di una parte di esso, in dipendenza dalla
definizione o meno di una particolare condizione.
Non e' necessario che TEST valga 1, l'importante e' che il simbolo
TEST (simbolo e' una parola grossa, ma e' per farmi capire) sia
definito in fase di *compilazione*.
L'uso degli #ifdef offre diversi vantaggi, considerando anche il fatto
che e' possibile compiere la stessa operazione di #define al volo, al
momento della compilazione.
Immagina un codice di questo tipo :
int main()
{
    for ( int i = 0 ; i < 10 ; i++ )
    {
        bool k = elaborazione() ;
        #ifdef DEBUG 
               if ( k )
                  puts("elaborazione ok !" ) ;
               else
                  puts("elaborazione fallita !" ) ;    
        #endif
    }
}
A seconda che DEBUG sia definita o meno il compilatore produrra',
rispettivamente, i seguenti codici :
// con DEBUG definita
int main()
{
    for ( int i = 0 ; i < 10 ; i++ )
    {
        bool k = elaborazione() ;
        if ( k )
           puts("elaborazione ok !" ) ;
        else
           puts("elaborazione fallita !" ) ;    
    }
}
// con DEBUG non definita 
int main()
{
    for ( int i = 0 ; i < 10 ; i++ )
    {
        bool k = elaborazione() ;
    }
}

 calcolo delle due radici non cambia nulla!
Beh, ci sono anche degli output su cout, se non sbaglio.
EMG

 definito in fase di *compilazione*.
Non so se sia standard (nel DJGPP è supportato) ma l'amico non parlava
di #ifdef bensì di #if che invece richiede che il simbolo sia definito
con un valore vero o falso.
EMG

Vi ringrazio, forse ho capito. Se non sbaglio infatti l'espressione
condizionale del preprocessore viene molto utilizzata negli header file (o
sbaglio?), cosicchč del file .h si compili poi solo la parte di codice che
risponde all'#if (condizione) e che quindi serve.
Lo scoprirņ procedendo nel mio percorso!
Grazie e ciao!

con un valore vero o falso.
In fin dei conti, vale lo stesso discorso.

 In fin dei conti, vale lo stesso discorso.
Si, certo.
EMG

Lo scoprirò procedendo nel mio percorso!
Esatto, e' esattamente questo il suo scopo.
La compilazione condizionale puo' servire per dare in pasto al
compilatore sorgenti diversi a seconda se si stia utilizzando un
sistema operativo o l'altro.
Definire qualcosa inizialmente, puo' segnare a priori il percorso da
seguire nella compilazione.