Commande de préprocesseur d'apprentissage #Define, #UNDEF en C

Il existe plusieurs commandes de préprocesseur qui existent dans la langue C. # Define et # Undef sont la commande de préprocesseur la plus importante présente dans la langue C. Chacun d'eux a des fonctionnalités uniques. Dans ce sujet, nous discuterons en détail # définir et # undef.

Qu'est-ce que le préprocesseur?

Avant de discuter de # définir et # undef, nous devons connaître le préprocesseur.

Un préprocesseur est un programme qui fonctionne avant la compilation. Dans le code source, le préprocesseur ne remarque que les instructions # symbole démarrées. Le reste des lignes reste inchangé par le processeur. # s'appelle la directive du préprocesseur. Chaque directive de processeur doit être sur sa propre ligne. Le mot après # est appelé commande de préprocesseur. # Define et # undef sont les directives du préprocesseur.

Commande de processeur #define dans le langage C

La directive # Define définit un identifiant et une séquence de caractères (un ensemble de caractères) qui sera remplacé par l'identifiant que chacun a rencontré dans le fichier source.

# définir pi 3.14.
# s'appelle la directive préprocesseur.

Définir est appelé une commande de préprocesseur.

Pi est appelé identifiant ou macro.

3.14 sont appelés une séquence de caractère.

# s'appelle la directive préprocesseur. Il indique le préprocesseur pour traiter ou exécuter la ligne.

Après avoir écrit la directive du préprocesseur, nous écrivons immédiatement la commande du préprocesseur. Il existe de nombreux types de commandes présentes dans la langue C. Define est l'une des commandes de processeur écrit ici. Avec ces commandes, le processeur peut comprendre ce que cela sera fait.

Après cela, nous écrivons un mot qui est appelé macro. Ici, nous écrivons une macro qui s'appelle pi. Il peut être écrit à la fois dans la capitale ou en petites lettres. Ici, nous écrivons dans une petite lettre.

Après avoir utilisé la macro, nous écrivons immédiatement une séquence de caractères. La séquence de caractères peut être un nombre ou une chaîne. Ils peuvent être n'importe quel type en fonction de l'exigence du programmeur. Ici, nous utilisons une séquence de caractères 3.14. Dans tout le programme où nous écrivons Pi, le préprocesseur remplace ce Pi par 3.14. Nous avons donc en fait défini une valeur de Pi une fois, le préprocesseur remplace tout le PI à 3.14. Ainsi, lorsque le compilateur compile le programme, il peut voir toutes les valeurs PI à 3.14.

Syntaxe générale

# Définir la séquence de Macro-Name CHAR

L'identifiant est appelé un nom de macro et le processus de remplacement comme un remplacement de macro.

Exemple

# définir pi 3.14
# Définir MSG «Bonjour le préprocesseur»

Exemple de programmation 1

#inclure
#define sum (a, b) a + b
int main ()

printf («La somme de 5 et 6 est% d», somme (5,6));
retour 0;

Sortir

Explication

Ici, nous utilisons une commande de pré-incessante définir. Nous écrivons une ligne:

#define sum (a, b) a + b

"#" Est la directive préprocesseur. Après «#», nous écrivons immédiatement la commande de définition du préprocesseur. Après cela, nous écrivons un identifiant ou une macro nommée SUM (A, B). Ensuite, nous écrivons une séquence de caractères A + B.

Pour voir la directive «#», le préprocesseur peut comprendre que c'est la ligne qui doit être résolue. En écrivant la commande Define, le préprocesseur peut comprendre quelle sera l'action effectuée par le préprocesseur. Ensuite, le préprocesseur macro-somme (A, B) et A + B remplace toute la somme macro (a, b) par la séquence de caractères A + B. Cela signifie que lorsque le compilateur compile le programme, il peut voir un + b à la place de la somme (a, b) partout où il est utilisé. Nous écrivons donc une macro une seule fois, et il peut être utilisé plusieurs fois dans notre programme.

Exemple de programmation 2

#inclure
#Define Produit (A, B) A * B
int main ()

printf («Le produit de 5 et 6 est% d», produit (5 + 6, 4-6));
retour 0;

Sortir

Explication

Ici, nous utilisons une autre commande de préprocesseur définir. Nous écrivons une ligne:

#Define Produit (A, B) A * B

"#" Est la directive préprocesseur. Après «#», nous écrivons immédiatement la commande de définition du préprocesseur. Après cela, nous écrivons un identifiant ou un produit nommé macro (A, B). Ensuite, nous écrivons une séquence de caractères a * b.

Pour voir la directive # Preprocesseur peut comprendre que c'est la ligne qui doit être résolue. En écrivant la commande Define, le préprocesseur peut comprendre quelle sera l'action effectuée par le préprocesseur. Ensuite, le préprocesseur de macro (A, B) et A * B remplacer tout le produit macro (A, B) par la séquence de caractères A * B. Cela signifie que lorsque le compilateur compile le programme, il peut voir un * b à la place du produit (a, b) partout où il est utilisé. Nous écrivons donc une macro une seule fois, et il peut être utilisé plusieurs fois dans notre programme.

Le mécanisme réel de cet exemple particulier est

Produit (5 + 6,5-6)
a = 5 est faux ici.
Le calcul correct est:
5 + 6 * 5-6
= 5 + 30-6
= 35-6
= 29.

Donc, le résultat est 29.

Exemple de programmation 3

#inclure
#define carré (a) a * a
int main ()

int s = carré (5)
printf («Le carré de% d», s);
retour 0;

Sortir

Explication

Ici, nous utilisons une autre commande de préprocesseur définir. Nous écrivons une ligne:

#define carré (a) a * a

"#" Est la directive préprocesseur. Après «#», nous écrivons immédiatement la commande de définition du préprocesseur. Après cela, nous écrivons un identifiant ou une macro nommée Square (A). Ensuite, nous écrivons une séquence de caractères a * a.

Pour voir la directive # Preprocesseur peut comprendre que c'est la ligne qui doit être résolue. En écrivant la commande Define, le préprocesseur peut comprendre quelle sera l'action effectuée par le préprocesseur. Ensuite, le macro carré (a) et un * un préprocesseur remplace tout le macro carré (a) à la séquence de caractères a * a. Cela signifie que lorsque le compilateur compile le programme, il peut voir un * a à la place du carré (a) partout où il est utilisé. Nous écrivons donc une macro une seule fois, et il peut être utilisé plusieurs fois dans notre programme.

#UNDEF

Il est utilisé pour les macros non définies. Chaque fois que nous réalisons qu'aucune macro n'est requise dans le programme, nous écrivons simplement:

#UNDEF Macro-Name

Il n'y a aucune exigence pour une séquence de caractères.

Exemple de programmation 4

#inclure
#define Avisisk avi
int main ()

#undef avi
# Si défini (AVI)
printf («Je suis professeur»);
# autre
printf («macro a été non défini \ n»);
# endif // défini.
retour 0;

Sortir

Explication

Ici, nous définissons une macro nommée Avisishek, et elle remplace par une séquence de caractères avi. Il n'est également pas défini par "#Undef". Chaque fois que la macro n'est plus requise dans le programme, nous utilisons la commande Prérocesseur undef pour indéfinir la macro.

Conclusion

Ici, nous apprenons les utilisations de «#» définir et # undef en détail. Alternativement, nous apprenons également les utilisations de la macro. Comment puis-je l'appliquer, et chaque fois que la macro n'est plus requise dans le programme, alors non défini en utilisant "#Undef". Donc, c'est un bon concept dans le langage de programmation C.