#define        : définition d'une macro-substitution

Syntaxe:
      #define symbole <texte> <retour/chariot>
      #define symbole( <liste_parametres> ) <texte> <retour/chariot>


Description:

La première forme demande au pré-compilateur de remplacer, dans les lignes qui suivent, l'identificateur 'symbole' par les caractères de <texte>.
Le remplacement n'a pas lieu dans une chaine, dans un commentaire.
De plus la directive:

• '#ifdef symbole' a la valeur vrai
• '#ifndef symbole' a la valeur faux.
  
  Il est possible que <texte> soit absent, alors symbole est remplacé par 0 caractère.
  Voir l'exemple 1 ci-dessous.
  
  Avec la deuxième forme, qui est paramétrée, chaque apparition de symbole( <liste_arguments> ) est remplacée par les caractères de texte après que chaque paramètre apparaissant dans texte ait été sbstitué par l'argument correspondant.
  Voir l'exemple 2 ci-dessous.
  
  Remarques:
  
  
• Pour une macro-subtitution paramétrée, il ne faut pas d'espace entre le nom de la macro et la parenthèse ouvrante.Si un espace est présent après le nom de la macro, le compilateur considère qu'il n'y a pas de paramètre.
  Voir l'exemple 3 ci-dessous.
  
  
• La fin du texte est marquée par le caractère <retour-chariot>.
  Il faut donc une convention particulière pour écrire ce texte sur plusieurs lignes; cette convention est la suivante: en faisant précéder le caractère <retour-chariot> par \, alors le précompilateur remplace ce <retour-chariot> par un espace.
  Voir l'exemple 4 ci-dessous.
  
  
• Le texte généré par la précompilation peut être affiché si on utilise l'option -E sur la commande du système UNIX. exemple:
  cc -E essai.c
  
• Une deuxième macro-définition de symbole efface la première.
  
  
  Voir aussi:
       #undef       #ifdef  
  
  

  Exemple:

  
  exemple 1: formes simples de macro-substitutions
  
  #define MAP
  #define SYMB "substitution"
  #define NB_ELEMENTS 10
  
  char * ch = "SYMB";
  double tab [ NB_ELEMENTS+1 ];
  
  permet la génération de:
  char * ch = "SYMB";
  double tab [ 10+1 ];
  
  exemple 2: forme paramétrée de macro-substitution
  
  #define DECL(type, nom, taille) type nom[taille]
  
  DECL ( double, td, 18 );
  DECL( int, ti, 8+8);
  
  permet la génération de:
  double td[18];
  int ti [8+8];
  
  exemple 3: soit la définition (remarquer un espace après DECL2)
  
  #define DECL2 (type, nom, taille) type nom[taille]
  
  alors la génération de
  
  DECL2 ( double, td, 18 );
  
  est:
  
  (type, nom, taille) type nom[taille] ( double, td, 18 );
  
  exemple 4: définition présentée sur plusieurs lignes
  
  #define MEMALLOC( type, ptr, taille) \
  ptr = (type *) malloc(taille); \
  if(ptr==NULL) { \
  printf("Pas assez de mémoire disponible\n"); \
  exit (1); \
  }
  
  
  exemple 5: texte généré visible par l'option -E
  placer les 20 lignes ci-dessous dans le fichier essai.c
  et exécuter la commandes cc -E essai.c
  
  #define SYMB "substitution"
  
  #define NB_ELEMENTS 10
  
  #define MAX( x, y) ( (x) > (y) ? (x) : (y) )
  
  main() {
  char * ch = "SYMB";
  double tab [ NB_ELEMENTS ];
  double dd, nb1=3.14159;
  
  printf("*** %s \n", ch);
  printf("*** %s \n", SYMB);
  printf("*** nombre d'éléments : %d \n", sizeof tab / sizeof tab[0]);
  
  dd = MAX ( 22 / 7.0, nb1 );
  printf("*** 22 / 7.0 = %lf, pi proche de %lf\n", 22/7.0, nb1);
  printf("*** Le plus grand est : %lf\n", dd);
  }
  
  /* Le texte généré par le précompilateur est :
  #line 1 "essai.c"
  
  
  
  main() {
  char * ch = "SYMB";
  double tab [ 10 ];
  double dd, nb1=3.14159;
  
  printf("*** %s \n", ch);
  printf("*** %s \n", "substitution");
  printf("*** nombre d'éléments : %d \n", sizeof tab / sizeof tab[0]);
  
  dd = ( (22 / 7.0) > (nb1) ? (22 / 7.0) : (nb1) );
  printf("*** 22 / 7.0 = %lf, pi proche de %lf\n", 22/7.0, nb1);
  printf("*** Le plus grand est : %lf\n", dd);
  }
  
  */
  
  

   Table des matières         Index