#define

 #define

Après ce petit rappel de #include, passons à #define.

Les defines permettent de définir des constantes de préprocesseur.

Comment je fais ça moi ?
C'est pas avec le mot clé const ?

Non, regardez :

#define MON_TEXTE_DE_BIENVENUE "Salut ca va ?"

C'est tout simple (comme le chapitre) !
Il faut écrire respectivement (dans l'ordre) le #define, puis le nom de la constante de préprocesseur, et enfin sa valeur.

La valeur est facultative, nous verrons plus tard qu'un define sans valeur est très utile.

Attention, la valeur de la constante n'est pas balisée même s'il y a des espaces.
Les guillemets que j'ai mis en exemple font partie de la valeur.

Pour comprendre à quoi ça sert, je vous ai préparé une petite animation :

Notez que j'écris le nom de la constante en majuscule, n'oubliez pas que j'écris toujours mes constantes en majuscules.

Le préprocesseur va analyser le code source et va remplacer tous les MON_TEXTE_DE_BIENVENUE par "Salut ca va ?" pour ensuite procéder à la compilation.

Une constante de préprocesseur n'est pas du tout la même chose qu'une simple constante (avec const), il ne se passe rien en mémoire, c'est un simple remplacement avant compilation.

Et si je veux faire un define sur plusieurs lignes ?
Je dois faire 2 defines ?

Surtout pas ! Il suffit d'utiliser le caractère \ en fin de ligne comme ci-dessous :

#include <stdio.h>
#include <stdlib.h>

#define MON_TEXTE_DE_BIENVENUE printf("Salut ca va ?\n\n");\
                               system("pause");

int main()
{
    MON_TEXTE_DE_BIENVENUE

    return 0;
}

Je pense que vous avez tout compris du premier coup d'oeil .
Vous voyez qu'ici, on utilise un define pour ajouter du code source, oui oui, c'est possible, la valeur d'un define peut être n'importe quoi.

Les defines sont très pratiques mais il ne faut pas en abuser.

Un autre exemple pour bien comprendre avec des nombres :

#include <stdio.h>
#include <stdlib.h>

#define LARGEUR_FENETRE 400
#define HAUTEUR_FENETRE 200

int main()
{
    int x = LARGEUR_FENETRE;
    int y = HAUTEUR_FENETRE;

    return 0;
}

Très simple une fois de plus.

Les calculs dans les defines

Voyons maintenant les calculs dans les defines ! Rassurez-vous, c'est une fois de plus très simple !
Vous pouvez faire toutes les opérations de base que vous connaissez comme l'addition (+), la soustraction (-), la multiplication (*), la division (/) et le modulo (%).

#define LARGEUR_FENETRE 400
#define HAUTEUR_FENETRE 200
#define RESOLUTION LARGEUR_FENETRE * HAUTEUR_FENETRE

La constante RESOLUTION sera remplacée dans le code source par LARGEUR_FENETRE * HAUTEUR_FENETRE donc par 400 * 200 ce qui fera 80000.
C'est le même principe qu'un simple define, la seule différence c'est qu'il a 3 remplacements à effectuer.

Les constantes prédéfinies

Je vais vous parler pour finir des constantes prédéfinies, celles qui existent déjà, celles que le préprocesseur connaît toujours.
Je ne vais pas vous mentir, elles sont très peu utilisées mais si vous les rencontrez un jour, vous saurez ce que c'est .

Chacune de ces constantes commence et se termine par 2 underscores (_) :

•__LINE__ donne le numéro de la ligne actuelle.

•__FILE__ donne le nom du fichier actuel.

•__DATE__ donne la date de la compilation.

•__TIME__ donne l'heure de la compilation.

Elles sont utilisées dans la plupart des cas pour gérer des erreurs.
Notez que je n'ai pas énuméré toutes les constantes prédéfinies, j'ai sélectionné l'essentiel.

Voilà, c'est tout pour les defines, c'est un simple remplacement de code source, on va pouvoir s'en servir dans les chapitres à venir (trop cool) !

Les macros

Premièrement, les macros sont des defines un peu particuliers, elles ressemblent beaucoup aux defines puisqu'elles nécessitent la directive #define.
On peut dire qu'une macro est une grosse define.
Une macro est en fait une constante comme les simples defines mais qui peut prendre un certain nombre d'arguments (de paramètres).
Les paramètres sont placés entre parenthèses après le nom de la macro sans espaces, par exemple :

#include <stdio.h>
#include <stdlib.h>

#define MON_TEXTE_DE_BIENVENUE(texte) printf(texte);

int main()
{
    MON_TEXTE_DE_BIENVENUE("Vive les macros toutes pourries de Tetdoss !")

    return 0;
}

On peut dire que la macro MON_TEXTE_DE_BIENVENUE remplace en quelque sorte la fonction printf.

Il ne faut pas mettre de guillemets autour de texte dans le printf sinon le préprocesseur ne saura pas que c'est ce mot texte qui doit être remplacé et donc ce sera texte qui sera affiché à l'écran.
En effet, la syntaxe d'une macro est plus importante qu'un simple define alors faites-y attention.
Le préprocesseur est un outil puissant s'il est maîtrisé.

Une petite animation pour encore mieux comprendre les macros :

Il y a peu de différences avec de simples defines mais il y en a !
Encore un autre exemple pour bien comprendre :

Je ne vous ai pas encore présenté une macro avec plusieurs paramètres !
Peu de différences mais bon à savoir :

#include <stdio.h>
#include <stdlib.h>

#define COMP(x, y) if (x > y)\
                  printf("x est supérieur a y.");\
                  else if (x < y)\
                  printf("x est inférieur a y.");\
                  else\
                  printf("x est égal a y.");

int main()
{
    COMP(14, 15);

    return 0;
}

Il faut donc retenir qu'une macro est un define qui a l'avantage de pouvoir prendre des paramètres.

Pour résumer la directive #define, le préprocesseur fait une recherche des constantes de préprocesseur pour les remplacer en fonction des defines que vous avez définis, il ne se passe donc rien en mémoire.

Créé avec HelpNDoc Personal Edition: Créer des livres électroniques EPub facilement