Vantaggi del condizionale-preprocessore oltre istruzioni condizionali

Question

Non ho mai lavorato con #if, #ifdef, #ifndef, #else, #elif e #endif.

Mentre stavo esaminando alcuni codici sorgente, ho trovato un ampio uso di queste direttive. Ha fatto qualche lettura sui preprocessori condizionali ma non ha trovato alcun indizio come in che modo sono diversi dalle normali istruzioni condizionali. Così mi chiedevo che cosa è il vantaggio di codice seguente:

#include<iostream> 
int main() 
{ 
    int i = 0; 

    #if i == 0 
     std::cout<<"This"; 
    #else 
     std::cout<<"That"; 
    #endif 
    return 0; 
} 

su questo:

#include<iostream> 
int main() 
{ 
    int i = 0; 

    if (i == 0) 
     std::cout<<"This"; 
    else 
     std::cout<<"That"; 
    return 0; 
} 

Inoltre, quando da usare/non utilizzo condizionale-preprocessore?

Answer 1

Il preprocessore condizionale non funziona come nel primo esempio.

Sta funzionando con le costanti, vedi? Al momento della compilazione, esamina le varie condizioni e inserisce/omette il codice sorgente in base ad esso.

Ad esempio:

#define HAS_COMPARISON 

int main() { 
    #ifdef HAS_COMPARISON 
     int i = 0; 
     if(i == 0) std::cout << "This"; 
     else 
    #else 
     std::cout << "That"; 
    #endif 
} 

Con il set define, imposterà la variabile i ed eseguire il confronto ... in breve, il risultato sarà This. Se il commento è definito, l'intero blocco non sarà presente nel programma, il che significa che emetterà sempre That, senza mai impostare la variabile o eseguire il confronto.

Questo è l'uso più comune delle definizioni del preprocessore. È inoltre possibile definire valori e confrontarli con comportamenti variabili con la stessa definizione, ma questo è un altro problema.

Ancora una volta: il preprocessore condizionale viene valutato al momento della compilazione, le condizioni variabili vengono valutate in fase di esecuzione.

Answer 2

La compilazione condizionale significa che il codice ifdef-out non è mai effettivamente nell'applicazione finale collegata. Usare semplicemente le condizioni linguistiche significa che entrambi i rami sono nel codice finale rendendolo più grande e potenzialmente più difficile da testare ecc.

Utilizzare #ifdef ecc. Quando si sa in fase di compilazione cosa è richiesto. Le condizioni linguistiche vengono utilizzate quando non si conosce ciò che è necessario fino al runtime.

Answer 3

i vantaggi del preprocessore è che il codice viene espulso. Non viene compilato (richiede tempo) e non genera codice macchina che verrà caricato nella ram. Se la decisione è in un ciclo MOLTO stretto, molte volte, potrebbe esserci un miglioramento della velocità. Non dare per scontato che questo sia importante, a meno che tu non lo decida realmente.

Gli svantaggi del preprocessore è che ovviamente devi conoscere la risposta al momento della compilazione. Il codice sorgente ora contiene un sacco di codice che potrebbe non essere mai eseguito. Diventa più difficile rintracciare per un umano perché è spesso difficile determinare quali sarebbero stati quei valori in fase di compilazione.

Answer 4

L'esempio che hai mostrato non sembra utile a causa della mancanza di altre informazioni. Ma ecco un esempio che è utile #if.

#if OS == LINUX 
//do something 
#elif OS == SOLARIS 
//do something else 
#else 
// 
#endif 

La chiave è che #if viene valutata in fase di compilazione, ma if viene valutato quando programma viene eseguito.

#if BYTE_ORDER == LITTLE_ENDIAN 
//do something 
#else 
//do something else 
#endif 

Answer 5

L'uso delle direttive del preprocessore in questo caso non è del tutto utile. Ma l'uso di queste direttive per il preprocessore è utile in molti altri casi.

Queste direttive del preprocessore possono essere utilizzate per la compilazione condizionale. per esempio. Se alcuni programmi devono essere sviluppati per piattaforme multiple, le costanti specifiche della piattaforma possono avere valori. È possibile modificare la compilazione di questi valori specifici per la piattaforma mentre l'intero codice può essere mantenuto come un'unica grande entità.

Questi sono utili anche durante il debug. Le unità di test possono essere compilate nel codice ed eseguite usando queste compilazioni condizionali durante il debug e possono essere fermate dalla compilazione usando queste.