Menu

Directives de préprocesseur en C ++

preprocessor directives c

Essayez Notre Instrument Pour Éliminer Les Problèmes

Un aperçu détaillé des directives de préprocesseur en C ++.

Le préprocesseur est une fonctionnalité unique de C ++. En C ++, nous avons des étapes comme la compilation, la liaison et l'exécution pour un programme typique. En réalité, nous avons beaucoup d'autres fonctionnalités dans un programme C ++ qui doivent être traitées avant de passer le programme pour la compilation.

A cet effet, une étape spéciale appelée prétraitement est effectuée. Le prétraitement est effectué avant le processus de compilation et les fonctionnalités spéciales sont prétraitées. Par conséquent, un programme C ++ développé est obtenu, puis il est transmis au compilateur.

=> Visitez ici pour apprendre le C ++ à partir de zéro.

Directives de préprocesseur en C ++

Ce que vous apprendrez:

Aperçu

Les particularités du prétraitement sont identifiées à l'aide d'une entité appelée «directive préprocesseur». Ces directives de préprocesseur indiquent au compilateur que certaines informations du programme C ++ marquées par des directives de préprocesseur doivent être prétraitées avant la compilation.

Notez qu'en C ++ toutes les directives de préprocesseur commencent par un symbole «#». Au moment où le préprocesseur (une partie du compilateur) rencontre le symbole #, les informations qui suivent le symbole # sont prétraitées avant de passer le programme au compilateur.

Contrairement aux autres instructions C ++, les directives de préprocesseur ne se terminent pas par un point-virgule.

Dans ce tutoriel, nous explorerons les différentes directives de préprocesseur prises en charge par C ++.

Directives d'inclusion de fichiers

#comprendre

La directive d'inclusion de fichier #include nous permet d'inclure d'autres fichiers dans notre programme source. Nous pouvons inclure n'importe quel fichier d'en-tête contenant des définitions de diverses fonctions prédéfinies dans notre programme en utilisant ces fonctions. Nous pouvons inclure des fichiers d'en-tête dans notre programme en utilisant la syntaxe suivante.

#include

Exemple: #comprendre

Nous l'avons déjà vu dans nos programmes C ++. L'en-tête iostream contient les fonctions requises pour le streaming de données d'entrée / sortie comme cout, cin, etc.

À mesure que nos programmes deviennent plus volumineux ou que les fonctionnalités deviennent complexes, nous pourrions vouloir diviser notre programme en différents fichiers ou importer des fonctionnalités à partir des autres fichiers. Dans ce cas, nous utilisons des fichiers définis par l'utilisateur. Pour inclure des fichiers définis par l'utilisateur dans notre programme, nous pouvons utiliser la syntaxe suivante de la directive #include.

#include “filename”

Exemple: #include 'vector_int.h'

Il s'agit d'un fichier d'en-tête défini par l'utilisateur que nous avons l'intention d'inclure dans notre programme afin d'utiliser ses fonctionnalités.

L'exemple de code ci-dessous montre l'utilisation de la directive #include.

attente implicite et attente explicite dans le sélénium
#include using namespace std; int main() { cout<<'This is an example demonstrating inclusion directive #include'; }

Production:

Ceci est un exemple illustrant la directive d'inclusion #include.

Comme indiqué, nous avons utilisé la directive #include pour inclure la fonctionnalité de l'en-tête dans notre programme.

Directives de définition de macro

#définir

La directive #define est utilisée pour définir les constantes symboliques ou les macros dans le programme C ++.

La forme générale d'une directive #define est:

#define macro_name replacement code

Lorsqu'un préprocesseur rencontre la macro dans le programme, le préprocesseur remplace cette macro par le code qui est défini à l'aide de la directive #define avant que le code ne soit transmis au compilateur.

L'exemple de code ci-dessous montre une constante symbolique RADIUS qui est définie à l'aide de la directive #define et son utilisation dans le programme.

#include #define RADIUS 5 using namespace std; int main() { cout<<'Area of a circle : '<<3.142 * RADIUS * RADIUS; }

Production:

Aire d'un cercle: 78,55

Comme indiqué dans le programme, nous pouvons utiliser la constante symbolique RADIUS dans notre code et elle sera remplacée par la valeur définie pour elle à l'aide de la directive #define.

implémentation d'un graphe en c ++

Nous pouvons utiliser la directive #define pour définir un code de fonction approprié. Ces fonctions sont généralement de petites fonctions.

Un exemple est présenté ci-dessous.

#include #define REC_AREA(length, breadth) (length * breadth) using namespace std; int main() { int length = 20, breadth = 5, area; area = REC_AREA(length, breadth); cout << 'Area of a rectangle is: ' << area; return 0; }

Production:

L'aire d'un rectangle est: 100

Ici, en utilisant la directive #define, nous avons défini une fonction REC_AREA qui prend deux arguments c'est-à-dire longueur et largeur et calcule l'aire d'un rectangle. Dans la fonction principale, nous utilisons simplement cette macro et lui fournissons deux arguments pour obtenir l'aire d'un rectangle.

#undef

Les macros dans un programme défini avec la directive #define durent jusqu'à ce qu'elles ne soient pas définies à l'aide de la directive #undef. Une fois que le programme rencontre #undef, l'utilisation ultérieure de la macro (non définie par #undef) donnera une erreur de compilation.

Dans le programme ci-dessus, si nous donnons juste une instruction #undef REC_AREA après les déclarations d'entiers, alors le programme donnera une erreur de compilation.

Directives de compilation conditionnelle

Outre les directives expliquées ci-dessus, C ++ fournit également les directives suivantes qui peuvent être utilisées pour la compilation conditionnelle de code. Ces directives peuvent être utilisées sur des lignes similaires de l'instruction if-else de C ++.

Par exemple, nous pouvons activer DEBUG pour un programme sur ON ou OFF en utilisant ces directives conditionnelles.

Certaines des directives de compilation conditionnelle fournies en C ++ incluent:

  • #si
  • #elif
  • #fin si
  • #ifdef
  • #ifndef
  • #autre

Le programme ci-dessous illustre l'utilisation des directives de compilation conditionnelle dans un programme C ++.

#include using namespace std; #define DEBUG #define MAX(a,b) (((a)>(b)) ? a : b) int main () { int i, j; i = 100; j = 50; #ifdef DEBUG cout <<'Trace: Start of main function' << endl; #endif cout <<'The maximum is ' << MAX(i, j) << endl; #undef MAX //cout <<'The maximum is ' << MAX(10,20) << endl; #ifdef DEBUG cout <<'Trace: End of main function' << endl; #endif return 0; }

Production:

Trace: Début de la fonction principale
Le maximum est de 100
Trace: Fin de la fonction principale

Dans le programme ci-dessus, nous utilisons la directive #ifdef - #endif pour définir un DEBUG pour le programme. Ensuite, nous avons défini la fonction macro MAX à l'aide de la directive #undef. La directive de compilation conditionnelle construit #ifdef - #endif vérifie si DEBUG est défini et s'il est défini, il affiche peu de messages dans le programme.

Les # & ## opérateurs

Les opérateurs # et ## sont deux opérateurs spéciaux qui sont respectivement utilisés pour convertir un jeton de texte en une chaîne à afficher et concaténer deux jetons.

Ci-dessous, un exemple illustrant ces deux opérateurs.

#include using namespace std; #define MKSTR( x ) #x #define concat(a, b) a ## b int main () { cout <<'MKSTR(Hello World) = '<< MKSTR(Hello World) << endl; int xy = 100; cout <<'concat(x,y) = '<

Production:

MKSTR (Hello World) = Bonjour le monde
concat (x, y) = 100

Dans le programme ci-dessus, nous définissons MKSTR avec un argument x. Il a le corps #x. Lorsque nous imprimons ce MKSTR en utilisant l'argument «Hello World», nous voyons qu'à cause de #x, l'argument est converti en une chaîne et est affiché en sortie.

Ensuite, nous avons défini une fonction concat avec deux arguments a et b. Dans le corps, nous spécifions un ## b. Expression a ## b vaut ab. Ainsi, dans la fonction principale, lorsque nous appelons concat (x, y), il s'évalue en fait à xy qui est égal à la variable entière que nous avons définie.

Autres directives

#Erreur

La syntaxe générale de la directive #error est:

#error error_message

Lorsque le compilateur rencontre la directive #error, il affiche le message_erreur et la compilation s'arrête. L'argument error_message peut contenir un ou plusieurs mots avec ou sans guillemets.

#ligne

Cela indique au compilateur de changer le numéro de ligne et le nom de fichier stockés en interne du compilateur par le numéro de ligne et le nom de fichier donnés.

#ligne séquence de chiffres (“nom de fichier”)

Le digit_sequence peut être une constante entière.

Exemple:#line 200 test.c

Dans l'exemple ci-dessus, le numéro de ligne stocké en interne est défini sur 200 et le nom de fichier est changé en test.c.

#pragma

Fournit des instructions définies par l'implémentation au compilateur. Ces instructions sont spécifiques au compilateur et à la plate-forme. Si l'instruction ne correspond pas, la directive est ignorée sans générer d'erreur de syntaxe.

Macros prédéfinies

C ++ définit également de nombreuses macros prédéfinies qui peuvent être utilisées par les programmeurs.

Certaines de ces macros sont présentées sous forme de tableau ci-dessous.

Macro prédéfinieLa description
__DÉPOSER__Le nom de fichier actuel du programme en cours de compilation
__DATE__Date de traduction du code source en code objet au format mois / jour / année
__TEMPS__Heure au format heure: minute: seconde à laquelle le programme est compilé
__LIGNE__Le numéro de ligne actuel du programme en cours de compilation
__cplusplusConstante entière définie pour chaque version du compilateur

Le programme suivant illustre ces macros dans un programme.

#include using namespace std; int main () { cout<<'__LINE__ :' << __LINE__ << endl; cout<<'__FILE__ :' << __FILE__ << endl; cout<<'__DATE__ :' << __DATE__ << endl; cout<<'__TIME__ :' << __TIME__ << endl; cout<<'__cplusplus:'<<__cplusplus<

Production:

__LINE__: 5
__FILE__: prog.cpp
__DATE__: 15 avril 2019
__HEURE__: 12: 09: 15
__cplusplus: 201402

comment ouvrir un .dat déposer?

La sortie du programme ci-dessus est conforme à l'explication des macros prédéfinies ci-dessus et est explicite.

Conclusion

Dans ce didacticiel, nous avons vu diverses directives de préprocesseur fournies par C ++ avec leurs exemples. Les directives de préprocesseur nous aident à écrire des programmes plus efficaces et des programmes plus lisibles dans une certaine mesure.

Les directives de compilation conditionnelle nous permettent également de brancher la sortie de notre programme de différentes manières.

=> Recherchez la série complète de formations C ++ ici.

lecture recommandée

^