Menu

Direttive del preprocessore in C ++

preprocessor directives c

Prova Il Nostro Strumento Per Eliminare I Problemi

Uno sguardo dettagliato alle direttive del preprocessore in C ++.

Il preprocessore è una caratteristica unica di C ++. In C ++, abbiamo passaggi come la compilazione, il collegamento e l'esecuzione per un programma tipico. In realtà, abbiamo molte altre funzionalità in un programma C ++ che deve essere elaborato prima di passare il programma per la compilazione.

A tale scopo, viene eseguita una fase speciale chiamata preelaborazione. La preelaborazione viene eseguita prima del processo di compilazione e le funzioni speciali vengono preelaborate. Di conseguenza, si ottiene un programma C ++ espanso e quindi viene passato al compilatore.

=> Visita qui per imparare C ++ da zero.

Direttive del preprocessore in C ++

Cosa imparerai:

Panoramica

Le caratteristiche speciali per la preelaborazione vengono identificate utilizzando un'entità chiamata 'direttiva Preprocessore'. Queste direttive del preprocessore dicono al compilatore che alcune informazioni nel programma C ++ contrassegnate con direttive del preprocessore devono essere preelaborate prima della compilazione.

Notare che in C ++ tutte le direttive del preprocessore iniziano con un simbolo '#'. Nel momento in cui il preprocessore (parte del compilatore) incontra il simbolo #, le informazioni che seguono il simbolo # vengono preelaborate prima di passare il programma al compilatore.

A differenza delle altre istruzioni C ++, le direttive del preprocessore non terminano con un punto e virgola.

In questo tutorial, esploreremo le varie direttive del preprocessore supportate da C ++.

Direttive sull'inclusione dei file

#includere

La direttiva sull'inclusione dei file #include ci consente di includere altri file nel nostro programma sorgente. Possiamo includere qualsiasi file di intestazione che contenga definizioni di varie funzioni predefinite nel nostro programma utilizzando queste funzioni. Possiamo includere file di intestazione nel nostro programma utilizzando la seguente sintassi.

#include

Esempio: #includere

Lo abbiamo già visto nei nostri programmi C ++. L'intestazione iostream contiene le funzioni richieste per lo streaming di dati di input / output come cout, cin, ecc.

Man mano che i nostri programmi diventano più grandi o la funzionalità diventa complessa, potremmo voler dividere il nostro programma in vari file o importare funzionalità dagli altri file. In questo caso, utilizziamo file definiti dall'utente. Per includere file definiti dall'utente nel nostro programma possiamo fare uso della seguente sintassi della direttiva #include.

#include “filename”

Esempio: #include 'vector_int.h'

Questo è un file di intestazione definito dall'utente che intendiamo includere nel nostro programma per utilizzarne le funzionalità.

L'esempio di codice seguente mostra l'utilizzo della direttiva #include.

cosa fa il c ++
#include using namespace std; int main() { cout<<'This is an example demonstrating inclusion directive #include'; }

Produzione:

Questo è un esempio che mostra la direttiva di inclusione #include.

Come mostrato, abbiamo utilizzato la direttiva #include per includere la funzionalità dell'intestazione nel nostro programma.

Direttive sulla definizione delle macro

#definire

La direttiva #define viene utilizzata per definire le costanti simboliche o le macro nel programma C ++.

La forma generale di una direttiva #define è:

#define macro_name replacement code

Quando un preprocessore rileva la macro nel programma, il preprocessore sostituisce questa macro con il codice definito utilizzando la direttiva #define prima che il codice venga passato al compilatore.

L'esempio di codice seguente mostra una costante simbolica RADIUS definita utilizzando la direttiva #define e il suo utilizzo nel programma.

#include #define RADIUS 5 using namespace std; int main() { cout<<'Area of a circle : '<<3.142 * RADIUS * RADIUS; }

Produzione:

Area di un cerchio: 78,55

Come mostrato nel programma, possiamo usare la costante simbolica RADIUS nel nostro codice e sarà sostituita dal valore definito per essa usando la direttiva #define.

oracle pl sql intervista domande per esperti

Possiamo usare la direttiva #define per definire un codice funzione appropriato. Queste funzioni sono generalmente piccole funzioni.

Di seguito è mostrato un esempio.

#include #define REC_AREA(length, breadth) (length * breadth) using namespace std; int main() { int length = 20, breadth = 5, area; area = REC_AREA(length, breadth); cout << 'Area of a rectangle is: ' << area; return 0; }

Produzione:

L'area di un rettangolo è: 100

Qui utilizzando la direttiva #define abbiamo definito una funzione REC_AREA che accetta due argomenti, ovvero lunghezza e larghezza e calcola l'area di un rettangolo. Nella funzione principale, utilizziamo questa macro e le forniamo due argomenti per ottenere l'area di un rettangolo.

#undef

Le macro in un programma definito con la direttiva #define durano fino a quando non vengono definite utilizzando la direttiva #undef. Una volta che il programma incontra #undef, l'uso successivo della macro (non definita da #undef) darà un errore di compilazione.

Nel programma sopra, se diamo solo un'istruzione #undef REC_AREA dopo le dichiarazioni dei numeri interi, il programma restituirà un errore di compilazione.

Direttive sulla compilazione condizionale

Oltre alle direttive spiegate sopra, C ++ fornisce anche le seguenti direttive che possono essere usate per la compilazione condizionale del codice. Queste direttive possono essere utilizzate su righe simili dell'istruzione if-else di C ++.

Per esempio, possiamo impostare DEBUG per un programma su ON o OFF usando queste direttive condizionali.

Alcune delle direttive sulla compilazione condizionale fornite in C ++ includono:

  • #Se
  • #elif
  • #finisci se
  • #ifdef
  • #ifndef
  • #altro

Il programma seguente mostra l'utilizzo delle direttive di compilazione condizionale in un programma C ++.

#include using namespace std; #define DEBUG #define MAX(a,b) (((a)>(b)) ? a : b) int main () { int i, j; i = 100; j = 50; #ifdef DEBUG cout <<'Trace: Start of main function' << endl; #endif cout <<'The maximum is ' << MAX(i, j) << endl; #undef MAX //cout <<'The maximum is ' << MAX(10,20) << endl; #ifdef DEBUG cout <<'Trace: End of main function' << endl; #endif return 0; }

Produzione:

Traccia: inizio della funzione principale
Il massimo è 100
Traccia: fine della funzione principale

Nel programma sopra, usiamo la direttiva #ifdef - #endif per definire un DEBUG per il programma. Quindi abbiamo indefinito la funzione macro MAX utilizzando la direttiva #undef. La direttiva di compilazione condizionale costruisce #ifdef - #endif controlla se DEBUG è impostato e, se è impostato, stampa pochi messaggi nel programma.

Gli operatori # & ##

Gli operatori # e ## sono due operatori speciali che vengono utilizzati rispettivamente per convertire un token di testo in una stringa da visualizzare e concatenare due token.

Di seguito viene fornito un esempio che mostra entrambi questi operatori.

#include using namespace std; #define MKSTR( x ) #x #define concat(a, b) a ## b int main () { cout <<'MKSTR(Hello World) = '<< MKSTR(Hello World) << endl; int xy = 100; cout <<'concat(x,y) = '<

Produzione:

MKSTR (Hello World) = Hello World
concat (x, y) = 100

Nel programma sopra, definiamo MKSTR con un argomento x. Ha corpo #x. Quando stampiamo questo MKSTR utilizzando l'argomento 'Hello World', vediamo che a causa di #x, l'argomento viene convertito in una stringa e visualizzato nell'output.

Successivamente, abbiamo definito una funzione concat con due argomenti a e b. Nel corpo specifichiamo un ## b. L'espressione a ## b è uguale a ab. Così nella funzione main quando chiamiamo concat (x, y), in realtà restituisce xy che è uguale alla variabile intera che abbiamo definito.

Altre direttive

#errore

La sintassi generale della direttiva #error è:

#error error_message

Quando il compilatore incontra la direttiva #error, visualizza il messaggio error_message e la compilazione si interrompe. L'argomento error_message può contenere una o più parole con o senza virgolette.

#linea

Questo dice al compilatore di cambiare il numero di riga e il nome del file memorizzati internamente al compilatore con il numero di riga e il nome del file dati.

#linea sequenza di cifre ('nome file')

Digit_sequence può essere una costante intera.

Esempio:#line 200 test.c

Nell'esempio precedente, il numero di riga memorizzato internamente è impostato su 200 e il nome del file viene modificato in test.c.

#pragma

Fornisce al compilatore le istruzioni definite dall'implementazione. Queste istruzioni sono specifiche per il compilatore e la piattaforma. Se l'istruzione non corrisponde, la direttiva viene ignorata senza generare un errore di sintassi.

Macro predefinite

Il C ++ definisce anche numerose macro predefinite che possono essere utilizzate dai programmatori.

Alcune di queste macro sono elencate di seguito.

Macro predefinitaDescrizione
__FILE__Il nome del file corrente del programma in fase di compilazione
__DATA__Data di traduzione del codice sorgente in codice oggetto nel formato mese / giorno / anno
__TEMPO__Tempo nella forma ora: minuto: secondo in cui viene compilato il programma
__LINEA__Il numero di riga corrente del programma che si sta compilando
__cplusplusCostante intera definita per ogni versione del compilatore

Il seguente programma mostra queste macro in un programma.

#include using namespace std; int main () { cout<<'__LINE__ :' << __LINE__ << endl; cout<<'__FILE__ :' << __FILE__ << endl; cout<<'__DATE__ :' << __DATE__ << endl; cout<<'__TIME__ :' << __TIME__ << endl; cout<<'__cplusplus:'<<__cplusplus<

Produzione:

__LINE__: 5
__FILE__: prog.cpp
__DATA__: 15 aprile 2019
__TIME__: 12: 09: 15
__cplusplus: 201402

qual è il miglior strumento di rimozione del malware

L'output del programma sopra è in linea con la spiegazione delle macro predefinite sopra ed è autoesplicativo.

Conclusione

In questo tutorial, abbiamo visto varie direttive del preprocessore fornite da C ++ insieme ai loro esempi. Le direttive del preprocessore ci aiutano a scrivere programmi più efficienti e programmi più leggibili in una certa misura.

Le direttive sulla compilazione condizionale ci consentono anche di ramificare l'output del nostro programma in vari modi.

=> Cerca qui l'intera serie di formazione C ++.

Lettura consigliata

^