Wikipedia dit : En informatique, un préprocesseur est un programme qui procède à des transformations sur un code source, avant l'étape de compilation ou d'interprétation proprement dite.
define:
Les define permettent de mettre en place une nouvelle forme de constante dans vos programmes. Il existe comme vous le savez le mot-clé const
afin de rendre une variable constante (c'est à dire avec une valeur fixé et inchangeable). Seulement, l'utilisation de cette méthode requiert la création d'une nouvelle variable comme par exemple
const int SIZE = 10;
//ou
const std::string NAME = "Moteurprog";
Ceci n'est pas très grave mais une utilisation mémoire est donc utilisée dans un cas comme celui-ci!
Il existe une alternative avec des avantages mais aussi des inconvénients qu'il est bon de connaitre tout de même : la directive #define
la syntaxe est ma suivante:
#define SIZE 10
#define NAME Moteurprog
#define PI 3.14
c'est donc de la forme #defineespacenom de la constanteespacevaleur de la constante
La différence avec le mot clé const c'est que cette méthode consiste à remplacer la constante dans le code par la valeur précisée. Par exemple
si on a ce code là :
#include <iostream>
#define LOOP 10
int main( void ){
int i=0;
for(i = 0; i < LOOP; ++i)
std::cout<<i<<std::endl;
std::cout<<"Nombre de tours demandes: "<<LOOP<<std::endl;
system("pause");
return 0;
}
après un traitement du préprocesseur, le code qui sera compilé ainsi:
#include <iostream>
int main( void ){
int i=0;
for(i = 0; i < 10; ++i)
std::cout<<i<<std::endl;
std::cout<<"Nombre de tours demandes: "<<10<<std::endl;
system("pause");
return 0;
}
Comme vous pouvez le voir, chaque itération du mot LOOP a été transformée par la valeur fournie (ici 10)!
avantages:
* pas d'utilisation mémoire
* rapidité pour voir les constantes parmi les directives du préprocesseur
inconvénient:
* les valeurs ne sont pas typées ce qui peut engendrer des erreurs (on peut très bien mettre #define SIZE 10 comme #define SIZE Moteurprog
ce qui ne collerait pas avec le type de donné attendu)
Remarques:
* Souvent, comme toutes les constantes de manière générale, le nom des #define se met en majuscules
* Les #define se mettent en général dans les headers pour plus de clarté
Macro:
Le fonctionnement des macro est très similaire aux constantes #define et utilise lui aussi la commande #define
Je pense que le plus simple pour illustrer cette méthode est des exemples, donc en voici:
#include <iostream>
//Macro simple
#define HELLO() std::cout<<"coucou!"<<std::endl;
#define BYEBYE() std::cout<<"Je pars, ciao!"<<std::endl;
#define PAUSE() system("pause");
#define HISTOIRE() std::cout<<"toto est un gentil"<<std::endl;
std::cout<<"garcon malgre son age"<<std::endl;
//Macro avec argument
#define DRAW(text) std::cout<<text<<std::endl;
#define ADD(value1, value2) std::cout<<value1+value2<<std::endl;
int main( void ){
HELLO() //affiche "coucou"
HISTOIRE() //affiche l'histoire de toto
DRAW("Maintenant je vais faire un calcul!") //affiche "maintenant je vais faire un calcul!"
ADD(2,5) //affiche 7
PAUSE() //fais une pause
return 0;
}
Le principe est le même: le préprocesseur remplace les occurrences par les lignes de commandes définies par la macro
avantages:
* ça peut être pratique pour certaines courtes fonctions appelées très couramment
* les macros se repèrent facilement dans le code
inconvénients:
* les arguments ne sont pas typés
* les macros les plus longues ne sont pas très claires
remarques:
* tout comme les constantes, les macros ont généralement un nom en majuscules
* il ne faut pas oublier le '' en fin de ligne pour une macro sur plusieurs lignes
Voila, vous savez tout les amis, j'espère avoir été clair, ciao
__________________________
............ Curtis: RTS 3D .............. ......
........... TeamMoteurProg...........
