Externe en C ++
int it;
char fn (int itg, char ch);
il = 5;
char fn (int itg, char ch)
char var = 'o';
if (itg == 1 && ch == 'a')
var = 'z';
return var;
La première ligne est une déclaration variable. La deuxième ligne aurait été une signature de fonction si elle n'avait jamais terminé avec un point-virgule suivi d'un corps de fonction. Cette deuxième ligne se terminant par un point-virgule est un prototype de fonction. C'est aussi une déclaration de fonction. La troisième ligne attribue une valeur à la variable entière: il s'agit d'une initialisation variable mais peut toujours être considérée comme une définition variable. Le reste du code est une définition de fonction. Il commence par la signature de la fonction, suivie du corps de la fonction.
Il y a une nuance en C ++ lorsqu'elle concerne la déclaration et la définition. L'énoncé suivant est une déclaration variable:
int it = 5;
Une déclaration de variable complète comme celle-ci, où la variable est introduite puis attribuée une valeur, est toujours une déclaration variable. Ainsi, une déclaration variable peut simplement introduire la variable seule ou l'introduction avec la définition.
Le code suivant (copié d'en haut) est une déclaration de fonction:
char fn (int itg, char ch)
char var = 'o';
if (itg == 1 && ch == 'a')
var = 'z';
return var;
Une déclaration de fonction complète comme celle-ci, où sa signature présente la fonction et est ensuite suivie par le corps de la fonction, est toujours une déclaration de fonction. Ainsi, une déclaration de fonction peut simplement être le prototype de fonction seul, ou il peut être la signature de la fonction avec le corps de la fonction.
Ainsi, une déclaration peut être avec ou sans définition. Une définition est comme une sous-partie d'une déclaration. Avec la variable, attribuer une valeur pour la première fois est en fait une initialisation et pas vraiment définie. Lorsqu'une variable est déclarée pour la première fois sans initialisation, son emplacement en mémoire est déjà fourni, mais il est vide. L'intégration dans une valeur à l'emplacement est une initialisation, qui termine la définition.
Traditionnellement, une application C ++ simple a trois fichiers. Il a un fichier principal qui peut être appelé le premier fichier. Il a un deuxième fichier et un fichier d'en-tête. L'utilisation du spécificateur externe peut réduire le nombre de fichiers à deux (à partir de trois). Cet article explique l'utilisation du spécificateur externe avec des variables et des fonctions pour éviter le fichier d'en-tête. Remarque: Dans le vocabulaire C ++, ces deux fichiers sont appelés unités de traduction.
Contenu de l'article
- Fichier d'en-tête sans extern
- externe sans fichier d'en-tête
- Constant et externe
- externe et statique
- Conclusion
Fichier d'en-tête sans extern
Traditionnellement, une application C ++ simple a trois fichiers: le fichier principal avec la fonction principale () qui peut être appelé le premier fichier, un deuxième fichier et un fichier d'en-tête. Le fichier d'en-tête doit avoir les déclarations de variables et de fonctions sans leurs définitions. Les définitions des déclarations d'en-tête devraient être dans le deuxième fichier. En haut du premier fichier, il doit y avoir,
#include "Head.HH "
Où la tête.HH est le nom du fichier d'en-tête, et il réside dans le répertoire de l'utilisateur. La directive inclue ne se termine pas par un point-virgule. Dans cette situation, les déclarations variables sans définitions, et les prototypes de fonction sans définitions de fonction dans le fichier d'en-tête, ne doivent pas être précédés du spécificateur externe. Et la demande devrait fonctionner.
Illustration
La variable et la fonction ci-dessus sont utilisées pour l'illustration ici.
Tapez le code suivant dans un éditeur de texte et enregistrez-le dans le répertoire de l'utilisateur, avec le nom, tête.HH:
int it = 5;
char fn (int itg, char ch);
Il n'y a que deux déclarations dans l'en-tête. Tapez suivant ce qui suit dans un document sans titre de l'éditeur de texte et enregistrez dans le répertoire de l'utilisateur, avec le nom, deuxième.CPP:
char fn (int itg, char ch)
char var = 'o';
if (itg == 1 && ch == 'a')
var = 'z';
return var;
Et ensuite, saisissez le code suivant dans un autre document sans titre de l'éditeur de texte et enregistrez-le dans le répertoire de l'utilisateur, avec le nom, d'abord.CPP:
#include "Head.HH "
#inclure
Utilisation de Namespace Std;
int main()
couter << it << endl;
couter << fn(1, 'a') << endl;
retour 0;
Compilez l'application avec la commande de terminal suivant:
G ++ d'abord.CPP deuxième.cpp -o complet.exe
Exécuter l'application avec,
./complet.exe
La sortie est:
5
z
Malheureusement, le fichier d'en-tête n'autorise pas une déclaration simple d'une variable (e.g., it) sans initialisation. Cependant, ce problème peut être résolu comme indiqué ci-dessous.
externe sans fichier d'en-tête
Le fichier d'en-tête peut être éliminé si le spécificateur externe est utilisé de manière appropriée. Il y aura une déclaration pour la variable et la fonction dans cette situation, chacune sans définition dans le premier (principal) fichier. Chacun sera précédé d'un externe.
Illustration
Tapez le code suivant dans un éditeur de texte et enregistrez-le dans le répertoire de l'utilisateur, avec le nom, d'abord.CPP:
#inclure
Utilisation de Namespace Std;
extern int it;
char Fn externe (int itg, char ch);
int main()
couter << it << endl;
couter << fn(1, 'a') << endl;
retour 0;
Ensuite, saisissez ce qui suit dans un document sans titre de l'éditeur de texte et enregistrez dans le répertoire de l'utilisateur avec le nom, deuxième.CPP:
int it = 5;
char fn (int itg, char ch)
char var = 'o';
if (itg == 1 && ch == 'a')
var = 'z';
return var;
La définition de la variable et de la fonction ont eu lieu dans le deuxième fichier. Dans le premier fichier ici, ils ont été déclarés sans définition. Aucun en-tête n'a été inclus dans cette nouvelle application. Seuls deux fichiers sont impliqués. Notez que la variable a été déclarée complètement dans le deuxième fichier mais sans le mot extern. Même la fonction a également été déclarée complètement sans le mot extern. Cependant, le mot "externe" doit précéder les déclarations partielles dans le premier fichier.
Compilez l'application avec la commande de terminal suivant:
G ++ d'abord.CPP deuxième.cpp -o complet.exe
Exécuter la demande avec,
./complet.exe
La sortie est:
5
z
Identique qu'avant, mais sans aucun fichier d'en-tête.
Ainsi, le spécificateur externe relie les déclarations entre deux fichiers. Un fichier doit faire la déclaration sans définition et avec externe. L'autre fichier doit faire une définition, qui serait une déclaration complète, mais sans extern.
Fichier d'en-tête et externe
L'application ci-dessus avait le problème que la variable devait être déclarée complètement dans le fichier d'en-tête. Afin d'avoir la déclaration d'une variable dans un fichier d'en-tête sans la définition, la variable doit être précédée d'un externe. Donc, s'il y a,
extern int it;
Dans le fichier d'en-tête, il y aurait
int it = 5;
dans le deuxième fichier, et il y aurait toujours
#include "Head.HH "
En haut du premier fichier (fichier principal).
Constant et externe
Dans des circonstances normales, une constante doit être initialisée. Par exemple,
const char ch = 'e';
est autorisé et
Const Char Ch;
N'est pas autorisé.
Cependant, avec le spécificateur externe, une constante peut être déclarée sans initialisation dans les premier et deuxième fichiers. Donc, si dans le premier fichier, il y a
Extern const char ch;
Dans le deuxième fichier, il y aura
char ch = 'e';
Sans const dans le deuxième fichier. Ch dans les deux fichiers est la même entité.
Remplacer le premier.Fichier CPP avec le contenu suivant et enregistrer:
#inclure
Utilisation de Namespace Std;
Extern const char ch;
int main()
couter << ch << endl;
retour 0;
Remplacer le second.Fichier CPP avec le contenu suivant et enregistrer:
char ch = 'e';
Compilez l'application avec la commande de terminal suivant:
G ++ d'abord.CPP deuxième.cpp -o complet.exe
Exécuter la demande avec,
./complet.exe
La sortie doit être, e.
externe et statique
Les spécificateurs de classe de stockage en C ++ sont statiques, thread_local, externe, mutable. Pas plus d'un d'entre eux ne peuvent être utilisés dans une déclaration donnée. Cependant, dans quelques cas, Thread_Local et Static peuvent apparaître devant une déclaration d'entité, ou thread_local et extern peuvent apparaître devant une déclaration d'entité. Ainsi, l'extérieur et le statique ne peuvent jamais être présents comme spécificateurs pour une déclaration.
Conclusion
Le spécificateur externe relie deux déclarations de la même entité, qui se trouvent dans deux fichiers différents. La déclaration ayant le spécificateur externe ne doit pas être initialisée ou définie. La déclaration dans l'autre fichier qui n'a pas le spécificateur externe doit être initialisée ou définie. Ce schéma s'applique aux variables et aux fonctions. Il élimine le besoin d'un fichier d'en-tête pour les variables et les fonctions d'intérêt. Il permet de déclarer une constante sans initialisation dans un fichier et dans l'autre fichier. Si le programmeur veut un fichier d'en-tête, afin d'avoir une variable dans le fichier d'en-tête, sans initialisation, le programmeur doit utiliser extern pour la variable dans le fichier d'en-tête.