C ++ pragma une fois
La langue C ++, parfois connue sous le nom de «C avec des classes», est un langage de programmation à usage général qui est une extension du langage informatique C. La langue C ++ s'est considérablement développée au fil du temps. Le C ++ actuel contient des capacités de gestion de la mémoire de bas niveau ainsi que des caractéristiques orientées objet, généralisées et fonctionnelles. Nous utilisons les bibliothèques d'en-tête dans la programmation C ++ pour éviter d'avoir à créer le code pour chaque petite chose. Les complexités et le nombre de lignes de code sont tous deux réduits. De plus, il vous permet de réutiliser les méthodes définies dans les fichiers d'en-tête à diverses fins.
La directive du langage C ++ gère #pragma une fois utilisée pour minimiser les erreurs de programmation. Bien qu'il soit soutenu par la majorité des traducteurs C ou C ++ de premier plan, y compris les traducteurs GCC et Clang, il n'est pas un composant de la norme C ++. Si le traducteur n'est pas fourni, cela pourrait susciter une préoccupation concernant l'accessibilité en fonction de votre programme. Lorsque vous utilisez #Pragma une fois, il y a un scénario exceptionnel où il existe de nombreux fichiers d'en-tête avec un nom de fichier similaire.
Avantages de #pragma une fois
Discutons de certaines des caractéristiques importantes de la directive du préprocesseur C ++ qui est la «#pragma une fois»:
- Comme nous le savons, le pragma ne compile qu'une seule fois dans le programme existant afin que l'implémentation ou le code du programme soit moindre.
- Puisque nous savons que le processus de compilation de Pragma est une fois, nous avons une évitement des tirets de noms.
- Dans d'autres programmes, lorsque nous compilons le programme, cela prend beaucoup de temps car le compilateur compile chaque fichier du programme. Mais lorsque nous utilisons la pragma une fois dans le programme, le code du programme est moindre. C'est pourquoi la vitesse de compilation du programme est rapide.
Mise en œuvre
Dans la programmation C et C ++, nous rencontrons parfois l'une des directives du préprocesseur qui est «#pragma une fois». Comme son nom l'indique, «une fois» signifie qu'il permet ou ne permet à un fichier source actuel d'être inclus dans le programme existant une seule fois à la fois, uniquement dans une seule compilation. Avant la directive du préprocesseur «#pragma une fois», il existe une autre directive préprocesseur que nous avons utilisée pour surmonter ce problème qui est «#include gardiens» dans le langage de programmation C ++. Mais Pragma n'autorise qu'une fois la compilation pour un car un programme qui a un programme automatique peut contenir plusieurs fichiers.
Le fichier C ++ peut inclure plusieurs fichiers d'en-tête. Cela signifie que le premier fichier C ++ et le deuxième fichier C ++ contiennent des fichiers d'en-tête similaires. Le compilateur compile le premier fichier d'en-tête puis le deuxième fichier d'en-tête. En effet, les deux fichiers d'en-tête sont compilés deux fois. Nous utilisons la directive Pragma une fois avant le préprocesseur afin que les fichiers d'en-tête se compilent une fois dans le programme existant.
Syntaxe:
Voici le style d'écriture et la mise en œuvre de la directive du préprocesseur «#pragma une fois» dans le langage de programmation C ++. Le préprocesseur recherche au programme des commandes spécifiques qu'il peut comprendre en les appelant des instructions de préprocesseur. Le panneau # (hachage) est utilisé au début de chaque directive pré-processeur. Premièrement, avant que le traducteur ne rencontre même le programme, le préprocesseur mène des activités préparatoires comme exécuter implicitement le code, y compris les fichiers liés au programme, etc.
Ensuite, nous écrivons le mot-clé «pragma» qui signifie «informations pragmatiques». La directive Pragma est incluse dans les normes C ++, mais l'interprétation de chaque directive Pragma dépend du programme utilisé pour exécuter la bibliothèque standard. Une technique pour demander au traducteur un comportement unique est avec la directive #Pragma. Cette commande est particulièrement utile pour les programmes qui doivent utiliser certaines fonctionnalités de code compilées ou qui sont exceptionnellement importantes. Et puis, en fin de compte, nous écrivons le comportement du programme que nous voulons mettre en œuvre sur le programme C ++ existant qui est «une fois». Cela signifie que lorsqu'il existe de nombreux fichiers d'en-tête avec un nom de fichier similaire, cela compile le fichier d'en-tête une seule fois.
Exemples:
Prenons un exemple de la directive du préprocesseur «#pragma une fois» et nous comprendrons comment cette directive fonctionne dans la langue C ++ afin que l'esprit et la confusion de l'utilisateur soient effacés à la fois sur les directives Pragma de la langue C ++:
Externe.H
Pour commencer à écrire le programme, nous avons toujours besoin d'un compilateur où nous écrivons et exécutons le programme existant. Installez n'importe quel compilateur C ++. Une autre chose est que la directive Pragma ne fonctionne pas sur le compilateur en ligne. Cet exemple est implémenté sur le compilateur "Dev C ++". Après avoir ouvert le compilateur, nous créons d'abord le «externe.Fichier H ”où nous implémentons la directive Pragma.
externe.H:#pragma une fois
#ifndef external_h
#define external_h
#inclure
Utilisation de Namespace Std;
joueur de classe
public:
INT Speed;
Joueur()
vitesse = 10;
~ Joueur ()
;
vide print ()
couter<< "Test" <
bool play = false;
#fin si
Tout d'abord, nous déclarons la directive pré-incessante «#pragma une fois» qui indique au compilateur d'inclure le code dans le fichier C ++ une fois. Ceci est utile si vous avez un fichier d'en-tête inclus dans plusieurs fichiers C ++. Ensuite, nous ajoutons le #include qui est un en-tête standard qui est inclus dans tous les programmes C ++. Dans la troisième ligne du code se trouve un #ifndef external_h. Il s'agit d'une directive de compilateur utilisée pour créer un fichier d'en-tête externe. Ensuite, nous implémentons à nouveau le #define external_h.
Après cela, nous déclarons le nom de la classe publique «Joueur» qui dit au compilateur que la classe des joueurs est publique. Ensuite, nous déclarons la variable de type entier «vitesse» et initialisons la valeur. Dans la ligne suivante, nous créons un constructeur de lecteur (). Maintenant, nous créons la fonction de print () et passons la méthode cout () dedans. Nous déclarons une variable de type bool jouant et initialisons la fausse valeur. Il s'agit d'une déclaration variable de membre pour la variable de membre de jeu. En fin de compte, nous utilisons le #endif car il s'agit d'une directive de compilateur qui est utilisée pour mettre fin à l'instruction #IFNDEF.
Principal.Fichier CPP
Tout d'abord, nous incluons le fichier que nous avons déjà créé - externe.h File. Ensuite, nous incluons le «#include» qui est utilisé pour obtenir les données de l'utilisateur et afficher les données à l'utilisateur. Ensuite, nous créons l'objet de joueur de joueur de type joueur que nous avons déjà défini dans l'extérieur.h File. Ensuite, nous appelons le joueur et le concatenons avec la variable de vitesse que nous avons initialisé dans le fichier externe et l'imprimer en utilisant la méthode cout (). Nous utilisons la statement if pour vérifier si le joueur joue. Si c'est vrai, il affiche le joueur. Si c'est faux, il n'affiche rien. En fin de compte, nous retournons 0 à la fonction principale () afin que nous puissions arrêter l'exécution du programme.
principal.CPP:#include "externe.H "
#inclure
Utilisation de Namespace Std;
int main ()
Joueur joueur;
couter<< "The speed of the player is: " <
Imprimer();
retour 0;
Conclusion
Dans cet article, nous avons découvert l'un des préprocesseurs importants de C ++ qui est «#pragma une fois». Nous avons appris pourquoi nous utilisons Pragma une fois et nous avons également discuté de ses avantages. Nous avons mis en œuvre l'exemple de Pragma une fois avec une explication détaillée de Pragma une fois la directive afin qu'aucun moment de confusion ne soit laissé à l'utilisateur.