Imparare il comando preprocessore #define, #undef in c

Esistono diversi comandi preprocessore che esistono nella lingua C. # define e # undef sono il comando preprocessore più importante presente nella lingua C. Ognuno di essi ha alcune caratteristiche uniche. In questo argomento, discuteremo in dettaglio # Define e # undef.

Cos'è il preprocessore?

Prima di discutere # Define e # undef, dobbiamo sapere sul preprocessore.

Un preprocessore è un programma che si comporta prima della compilation. Nel preprocessore del codice sorgente nota solo le istruzioni # simbolo avviate. Il resto delle linee rimane invariato dal processore. # è chiamata direttiva preprocessore. Ogni direttiva del processore deve essere sulla propria linea. La parola dopo # si chiama comando preprocessor. # define e # undef sono le direttive preprocessore.

Comando del processore #define in lingua c

La direttiva # Define definisce un identificatore e una sequenza di caratteri (un insieme di caratteri) che verrà sostituita con l'identificatore ciascuno riscontrato nel file di origine.

# Definisci PI 3.14.
# si chiama direttiva preprocessore.

Define è chiamato comando preprocessore.

Pi è chiamato identificatore o macro.

3.14 sono chiamati una sequenza di carattere.

# si chiama direttiva preprocessore. Indica il preprocessore per elaborare o eseguire la linea.

Dopo aver scritto la direttiva preprocessore, scriviamo immediatamente il comando preprocessore. Ci sono molti tipi di comandi presenti nella lingua C. Define è uno dei comandi del processore scritto qui. Con questi comandi, il processore può capire cosa sarà fatto.

Dopodiché, scriviamo una parola che si chiama macro. Qui scriviamo una macro che si chiama pi. Può essere scritto sia nella capitale che in piccole lettere. Qui scriviamo in una piccola lettera.

Dopo aver usato la macro, scriveremo immediatamente una sequenza di caratteri. La sequenza dei caratteri può essere un numero o una stringa. Possono essere qualsiasi tipo a seconda del requisito del programmatore. Qui usiamo una sequenza di caratteri 3.14. Nell'intero programma in cui scriviamo PI, il preprocessore sostituisce questo Pi con 3.14. Quindi abbiamo effettivamente impostato un valore di PI una volta, il preprocessore sostituisce tutto il PI a 3.14. Quindi, quando il compilatore compila il programma, può vedere tutti i valori PI a 3.14.

Sintassi generale

# Definisci macro-nome char-sequence

L'identificatore viene definito un nome macro e il processo di sostituzione come sostituzione macro.

Esempio

# Definisci PI 3.14
# Define MSG "Hello Preprocessor"

Esempio di programmazione 1

#includere
#define Sum (a, b) a+b
int main ()

printf ("La somma di 5 e 6 è %d", somma (5,6));
restituzione 0;

Produzione

Spiegazione

Qui usiamo un comando preprocessore Define. Scriviamo una riga:

#define Sum (a, b) a+b

"#" È la direttiva preprocessore. Dopo "#", scriviamo immediatamente il comando Define Preprocessor. Successivamente, scriviamo un identificatore o una macro denominata somma (a, b). Quindi scriviamo una sequenza di caratteri A+B.

Per vedere la direttiva "#", il preprocessore può capire che è la linea che deve essere risolta. Scrivendo il comando Define, il preprocessore può capire quale sarà l'azione eseguita dal preprocessore. Quindi il preprocessore macro (a, b) e a+b sostituisce tutta la macro somma (a, b) con la sequenza dei caratteri a+b. Significa quando il compilatore compila il programma, può vedere A+B al posto della somma (a, b) ovunque viene utilizzato. Quindi scriviamo una macro solo una volta e può essere utilizzata più volte nel nostro programma.

Esempio di programmazione 2

#includere
#define Product (a, b) a*b
int main ()

printf ("Il prodotto di 5 e 6 è %d", prodotto (5+6, 4-6));
restituzione 0;

Produzione

Spiegazione

Qui usiamo un altro comando preprocessore Define. Scriviamo una riga:

#define Product (a, b) a*b

"#" È la direttiva preprocessore. Dopo "#", scriviamo immediatamente il comando Define Preprocessor. Successivamente, scriviamo un identificatore o un prodotto macro denominato (A, B). Quindi scriviamo una sequenza di caratteri a*b.

Vedere la direttiva # preprocessore può capire che è la linea che deve essere risolta. Scrivendo il comando Define, il preprocessore può capire quale sarà l'azione eseguita dal preprocessore. Quindi il prodotto macro (A, B) e A*B preprocessore sostituiscono tutto il prodotto macro (A, B) con la sequenza dei caratteri A*B. Significa quando il compilatore compila il programma, può vedere A*B nel luogo del prodotto (a, b) ovunque viene utilizzato. Quindi scriviamo una macro solo una volta e può essere utilizzata più volte nel nostro programma.

Il meccanismo effettivo di questo particolare esempio è

Prodotto (5+6,5-6)
a = 5 è sbagliato qui.
Il calcolo corretto è:
5+6*5-6
= 5+30-6
= 35-6
= 29.

Quindi il risultato è 29.

Esempio di programmazione 3

#includere
#define Square (a) a*a
int main ()

int s = quadrato (5)
printf ("il quadrato di is %d", s);
restituzione 0;

Produzione

Spiegazione

Qui usiamo un altro comando preprocessore Define. Scriviamo una riga:

#define Square (a) a*a

"#" È la direttiva preprocessore. Dopo "#", scriviamo immediatamente il comando Define Preprocessor. Successivamente, scriviamo un identificatore o una macro chiamata Square (A). Quindi scriviamo una sequenza di caratteri a*a.

Vedere la direttiva # preprocessore può capire che è la linea che deve essere risolta. Scrivendo il comando Define, il preprocessore può capire quale sarà l'azione eseguita dal preprocessore. Quindi la macro quadrata (a) e un*preprocessore sostituiscono tutta la macro quadrata (a) alla sequenza dei caratteri a*a. Significa quando il compilatore compila il programma, può vedere a*a nel luogo del quadrato (a) ovunque viene utilizzato. Quindi scriviamo una macro solo una volta e può essere utilizzata più volte nel nostro programma.

#undef

È usato per macro indefinite. Ogni volta che ci rendiamo conto che non è richiesto più macro nel programma, scriviamo semplicemente:

#undef macro-nome

Non è necessario per nessuna sequenza di caratteri.

Esempio di programmazione 4

#includere
#define Avishek Avi
int main ()

#undef avi
# se definito (AVI)
printf ("I Am A Teacher");
# altro
printf ("La macro è stata indefinita \ n");
# endif // definito.
restituzione 0;

Produzione

Spiegazione

Qui definiamo una macro di nome Avishek e sostituisce una sequenza di caratteri Avi. È anche indefinito da "#undef". Ogni volta che la macro non è più richiesta nel programma, utilizziamo il comando preprocessore undef per indefinire la macro.

Conclusione

Qui apprendiamo gli usi di " #" Define e # Undef in dettaglio. In alternativa, apprendiamo anche gli usi della macro. Come posso applicarlo e ogni volta che la macro non è più richiesta nel programma, quindi indefinita usando "#undef". Quindi, è un buon concetto nel linguaggio di programmazione C.