où doit “inclure” être mis en C++
Je suis en train de lire certains de code c++ et de l'Avis qu'il y a "#include" à la fois dans les fichiers d'en-tête .fichiers cpp . Je suppose que si je me déplace tous les "#include" dans le fichier, disons foo.cpp aussi son " en-tête de fichier foo.hh et laissez foo.cpp inclure uniquement des foo.hh le code devrait fonctionner de toute façon sans tenir compte de questions comme les inconvénients , l'efficacité et etc .
Je sais que mon "tout à coup" idée doit être en quelque sorte une mauvaise idée, mais quelle est l'exacte des inconvénients de celui-ci? Je suis novice en c++ donc je ne veux pas de lire beaucoup de C++ livre avant que je puisse répondre à cette question par moi-même. donc, il suffit de déposer la question ici pour votre aide . merci à l'avance.
Vous devez vous connecter pour publier un commentaire.
En règle générale, placez votre inclut les dans les .fichiers cpp quand vous le pouvez, et seulement dans la .h fichiers lorsque cela n'est pas possible.
Vous pouvez utiliser déclaration pour supprimer la nécessité d'inclure les en-têtes d'autres en-têtes dans de nombreux cas: cela peut aider à réduire le temps de compilation qui peut devenir un gros problème que votre projet se développe. C'est une bonne habitude à prendre tôt car en essayant de faire le tri, à une date ultérieure (lorsque son déjà un problème) peut être un cauchemar complet.
L'exception à cette règle est basé sur un modèle de classes (ou les fonctions): pour les utiliser, vous devez voir la définition complète, ce qui signifie habituellement de les mettre dans un fichier d'en-tête.
export
(qui est abandonné). cppreference.com/wiki/keywords/exportLes fichiers d'en-tête doit être uniquement celles qui sont nécessaires à l'appui de cet en-tête. Par exemple, si votre en-tête déclare un vecteur, vous devez inclure vecteur, mais il n'y a aucune raison de chaîne. Vous devriez être en mesure d'avoir un programme vide qui ne comprend que seul fichier d'en-tête et de compiler.
Dans le code source, vous devez comprend pour ce que vous appelez, bien sûr. Si aucun de vos en-têtes nécessaires iostream mais vous en avez besoin, pour la source, il doit être inclus séparément.
Inclure le fichier de la pollution est, à mon avis, l'une des pires formes de code de la pourriture.
edit: Heh. Ressemble à l'analyseur mange de la > et < symboles.
Vous ferais tous les autres fichiers, y compris votre fichier d'en-tête transitivement inclure tous les
#include
s dans votre en-tête de trop.En C++ (comme en C)
#include
est géré par le préprocesseur en insérant simplement le texte dans le#include
d fichier à la place de la#include
déclaration. Donc, avec beaucoup de#include
s, vous pouvez littéralement se vanter de la taille de votre compilable fichier de plusieurs centaines de kilo-octets et le compilateur a besoin pour analyser tout cela pour chaque fichier. Notez que le même fichier inclus dans les différents lieux doit être réanalysé de nouveau dans chaque endroit où il est#include
d! Cela peut ralentir la compilation d'une analyse.Si vous devez déclarer (mais pas à définir) des choses dans votre en-tête, utilisez avant la déclaration de au lieu de
#include
s.#include
dans votre .h les fichiers chaque fois que vous le pouvez. Parfois, il est inévitable. Par exemple, si Une classe a un membre de données de classe B puis A. h devra inclure B. h.Alors qu'un fichier d'en-tête ne doit comprendre que ce dont il a besoin, "ce dont il a besoin" est plus fluide que vous pourriez penser, et dépend de l'usage que vous faites de l'en-tête. Ce que je veux dire par là, c'est que certains en-têtes sont en fait l'interface de documents pour les bibliothèques ou d'autres codes. Dans ces cas, les en-têtes doivent inclure (et probablement les #include) tout autre développeur aura besoin pour utiliser correctement votre bibliothèque.
Y compris les fichiers d'en-tête de dans les fichiers d'en-tête est fine, est donc, y compris dans les fichiers c++, cependant, afin de réduire les temps de construire, il est généralement préférable d'éviter d'inclure un fichier d'en-tête à partir d'un autre en-tête, sauf si absolument nécessaire, surtout si de nombreux fichiers c++ inclure le même en-tête.
.hh (ou sur .h) les fichiers sont censés être pour les déclarations.
.rpc (ou .cc) les fichiers sont censés être pour les définitions et les mises en œuvre.
Réaliser d'abord qu'une instruction #include est littérale.
#include "foo.h"
littéralement copie le contenu de toto.h et colle où la directive include est dans l'autre fichier.L'idée est que certains autres fichiers bar.cpp et baz.cpp voudrez peut-être faire usage d'un code qui existe dans foo.cc. La manière de le faire qui, normalement, serait pour bar.cpp et baz.cpp pour
#include "foo.h"
pour obtenir les déclarations de fonctions ou de classes qu'ils voulaient utiliser, et puis au moment de la liaison, l'éditeur de liens serait de brancher ces utilisations dans les bar.cpp et baz.cpp pour la mise en œuvre de foo.cpp (c'est tout l'intérêt de l'éditeur de liens).Si vous mettez tout dans foo.h et a essayé de le faire, vous avez un problème. Dire que foo.h déclare une fonction appelée
doFoo()
. Si la définition du code) cette fonction est en foo.cc, c'est bien. Mais si le code dedoFoo()
est déplacé dans foo.h, et vous inclure foo.h à l'intérieur des foo.cpp, bar.cpp et baz.cpp, il y a maintenant trois définitions pour une fonction nomméedoFoo()
, et votre éditeur de liens se plaindre parce que vous n'êtes pas autorisé à avoir plus d'une chose avec le même nom dans le même champ d'application.Si vous #inclure l' .fichiers cpp, vous aurez probablement jusqu'à la fin avec des charges de "plusieurs erreurs" définition de l'éditeur de liens. Vous pouvez, en théorie, #inclure le tout dans une seule unité de traduction, mais cela signifie aussi que tout doit être refait à chaque fois que vous apportez une modification à un fichier unique. Pour la réalisation de projets concrets, c'est inacceptable, c'est pourquoi nous avons linkers et des outils comme faire.
Il n'y a rien de mal à utiliser le #include dans un fichier d'en-tête. C'est une pratique très courante, vous ne voulez pas à la charge de l'utilisateur d'une bibliothèque, avec aussi de se souvenir de ce que d'autres obscures en-têtes sont nécessaires.
Un exemple standard est
#include <vector>
. Vous obtient le vecteur de la classe. Et un radeau de CRT interne de l'en-tête des fichiers qui sont nécessaires pour compiler la classe vector correctement, des trucs que vous n'avez pas vraiment besoin et ne veulent pas savoir.Vous pouvez éviter de nombreuses erreurs de définition si vous utilisez "inclure les gardes".
Maintenant, si vous le #include "myheader.h" dans d'autres fichiers d'en-tête, cela inclus une fois (en raison de _myheader_h_ en cours de définition). Je crois que MSVC a un "#pragma once" avec la fonctionnalité équivalente.
#pragma once
est un standard de facto par maintenant - gcc supporte également, et je crois que certains autres le sont également.