Pourquoi #ifndef et #define sont-ils utilisés dans les fichiers d'en-tête C ++

Les codes C ++ peuvent parfois être longs et la répétition de certaines déclarations ou fonctions peut se produire. Avoir plusieurs fonctions avec des noms similaires génère une erreur pendant l'exécution du code et ne fournit pas aux utilisateurs la sortie souhaitée. Pour empêcher ces types d'erreurs d'avoir des identifiants répétés tels que les fonctions, la classe ou les variables, le Gardiens de tête sont utilisés, qui sont #ifndef et #définir. Ce sont des dérivés C ++ qui empêchent le contenu d'un fichier d'en-tête d'être utilisé plusieurs fois. Ces gardes garantissent que le contenu d'un fichier d'en-tête est utilisé une fois dans un fichier.

Dans cet article, la raison d'utiliser #ifndef et #définir Les gardes d'en-tête de votre code sont discutés.

Pourquoi #ifndef et #define sont-ils utilisés dans les fichiers d'en-tête C ++

En C ++, le #ifdef et #définir sont utilisés comme instruction pour le compilateur pour protéger / protéger l'utilisation multiple des fichiers d'en-tête. Pour cette raison, ils sont également appelés gardiens de tête. Il existe une syntaxe spécifique qui doit être suivie pour utiliser #ifndef et #définir. Donc, la syntaxe est que chaque fois #ifndef est utilisé, l'utilisateur est également tenu de le terminer en utilisant #fin si et entre ces déclarations ou fichiers d'en-tête peuvent être ajoutés:

Syntaxe

#ifndef file_h
#define file_h
// code de déclaration
#fin si

Dans le code C ++, #ifndef et #définir Identifier et empêcher la redéclations des classes, des énumériques, des variables statiques ou tout autre identifiant. Ceci est utile dans des scénarios où plusieurs classes / fonctions sont créées et sont appelées dans des programmes. Parce que plusieurs fois, cela se produit lorsqu'un code complexe avec plusieurs classes et objets est conçu et que les développeurs ont tendance à répéter certains identifiants dans différents fichiers. Par exemple, supposons qu'un utilisateur a créé deux fichiers corrélés I.e fichier1.H et un fichier2.H et a inclus le fichier1.h dans le fichier2.H et vice versa.

Ce faisant, une répétition se produit provoquant une récursivité. Pour éviter cette récursivité si l'utilisateur ajoute #ifndef et #définir Fichiers d'en-tête, puis ces en-têtes demanderont au compilateur d'empêcher cette récursivité.

Qu'est-ce que la récursivité dans un code et comment "#ifndef" et "#définir" Aide à la récursivité

La récursivité fait référence à la capacité d'une fonction à être incluse plusieurs fois dans un code source. Avoir une récursivité dans un code générera différents types d'erreurs de compilation, telles que plusieurs définitions, la redéfinition des symboles et plus. Pour empêcher cette récursivité, nous utilisons "#Ifndef" et "#définir" gardiens de tête.

Suivi avec un exemple sur la façon dont "#Ifndef" et "#définir" empêche la récursivité dans un code. Supposons qu'il y ait un fichier d'en-tête "X.h ” Cela inclut le fichier d'en-tête "y.h ”, et l'autre fichier de tête "y.h ” Comprend «X.h ”. C'est ce qu'on appelle l'inclusion récursive, et elle créera des erreurs lorsque vous compilez le code. Pour éviter cela, nous pouvons utiliser #ifndef et #définir dans X.H et y.H comme suit:

Le fichier d'en-tête X.H est donné ci-dessous:

#ifndef x_h
#define x_h
#include "y.H "
// Contenu du fichier d'en-tête restant
#fin si

Le fichier d'en-tête y.H est donné ci-dessous:

#ifndef y_h
#define y_h
#include "x.H "
// Contenu du fichier d'en-tête restant
#fin si

Ici, X_h et Y_h sont des symboles uniques définis par #définir. La première fois X.H est inclus, X_h ne sera pas défini, donc le préprocesseur le définira et inclura y.H. Quand y.H est inclus, Y_h ne sera pas défini, donc le préprocesseur le définira et inclura X.H encore. Cependant, cette fois, A_h sera défini, donc le préprocesseur sautera l'inclusion de X.H.

De cette façon, l'inclusion récursive est empêchée et le programme peut être compilé sans erreurs.

Conclusion

Le #ifndef et #définir sont connus comme gardiens de tête pour C ++ qui sont utilisés pour prévenir / protéger la récursivité ou la répétition des identifiants. Les gardes d'en-tête sont utilisés pour le prétraitement et c'est pourquoi ils sont utilisés à l'intérieur du .H fichiers h (en-tête) fichiers et non dans le principal .cpp Fichier (compilableable). La syntaxe et l'utilisation de la tête de tête sont discutées dans les directives mentionnées ci-dessus.