Dans mon projet, j'ai cr=E9e un global.h qui contient tous les includes
des librairies annexes que j'utilise.
Du coup je mets ce global.h dans l'ent=EAte de mes classes ( qui
n'utilisent pas n=E9cessairement toutes les librairies =E0 la fois ).
Question : Est-ce qu'il vaut mieux mettre les #include au cas par cas
dans chaque header de les classes ? ( Et pourquoi ? )
Merci
G
ma principale motivation =E9tait de ne pas copier / coller des tonnes de
#include dans chaque .h
Question : Est-ce qu'il vaut mieux mettre les #include au cas par cas dans chaque header de les classes ? ( Et pourquoi ? )
Oui. Parce que ce que tu fais augmente le couplage entre tes classes, tu modifies un fichier et tu dois tout recompiler. Tu utilises un entête quelque part, et tu dois fournir tous ceux inutilement inclus.
Idéalement, il faudrait que chaque entête soit autosuffisant: qu'il contienne ce qu'il faut pour pouvoir être inclus en premier (et rien d'autre). Une technique pour s'en assurer est de faire en sorte que chaque entête soit le premier fichier inclus dans au moins une unité de compilation, celle qui défini les fonctions qui y sont déclarées.
L'utilisation des entêtes précompilés change un peu la donne par rapport à cette situation, mais je manque trop d'expérience en la matière pour pouvoir donner des conseils.
A+
-- Jean-Marc FAQ de fclc++: http://www.cmla.ens-cachan.fr/~dosreis/C++/FAQ C++ FAQ Lite en VF: http://www.ifrance.com/jlecomte/c++/c++-faq-lite/index.html Site de usenet-fr: http://www.usenet-fr.news.eu.org
Gégé <valasg@gmail.com> writes:
Question : Est-ce qu'il vaut mieux mettre les #include au cas par cas
dans chaque header de les classes ? ( Et pourquoi ? )
Oui. Parce que ce que tu fais augmente le couplage entre tes classes, tu
modifies un fichier et tu dois tout recompiler. Tu utilises un entête
quelque part, et tu dois fournir tous ceux inutilement inclus.
Idéalement, il faudrait que chaque entête soit autosuffisant: qu'il
contienne ce qu'il faut pour pouvoir être inclus en premier (et rien
d'autre). Une technique pour s'en assurer est de faire en sorte que chaque
entête soit le premier fichier inclus dans au moins une unité de
compilation, celle qui défini les fonctions qui y sont déclarées.
L'utilisation des entêtes précompilés change un peu la donne par rapport à
cette situation, mais je manque trop d'expérience en la matière pour
pouvoir donner des conseils.
A+
--
Jean-Marc
FAQ de fclc++: http://www.cmla.ens-cachan.fr/~dosreis/C++/FAQ
C++ FAQ Lite en VF: http://www.ifrance.com/jlecomte/c++/c++-faq-lite/index.html
Site de usenet-fr: http://www.usenet-fr.news.eu.org
Question : Est-ce qu'il vaut mieux mettre les #include au cas par cas dans chaque header de les classes ? ( Et pourquoi ? )
Oui. Parce que ce que tu fais augmente le couplage entre tes classes, tu modifies un fichier et tu dois tout recompiler. Tu utilises un entête quelque part, et tu dois fournir tous ceux inutilement inclus.
Idéalement, il faudrait que chaque entête soit autosuffisant: qu'il contienne ce qu'il faut pour pouvoir être inclus en premier (et rien d'autre). Une technique pour s'en assurer est de faire en sorte que chaque entête soit le premier fichier inclus dans au moins une unité de compilation, celle qui défini les fonctions qui y sont déclarées.
L'utilisation des entêtes précompilés change un peu la donne par rapport à cette situation, mais je manque trop d'expérience en la matière pour pouvoir donner des conseils.
A+
-- Jean-Marc FAQ de fclc++: http://www.cmla.ens-cachan.fr/~dosreis/C++/FAQ C++ FAQ Lite en VF: http://www.ifrance.com/jlecomte/c++/c++-faq-lite/index.html Site de usenet-fr: http://www.usenet-fr.news.eu.org
Gégé
Typiquement j'utilise massivement
#include<string> using namespace std;
Dois-je le mettre dans chaque header? Ou y t-il une subtilité ?
Merci pour d'avance
G
Typiquement j'utilise massivement
#include<string>
using namespace std;
Dois-je le mettre dans chaque header?
Ou y t-il une subtilité ?
Dois-je le mettre dans chaque header? Ou y t-il une subtilité ?
Merci pour d'avance
G
Jean-Marc Bourguet
Gégé writes:
Typiquement j'utilise massivement
#include<string> using namespace std;
Dois-je le mettre dans chaque header?
De mon point de vue, il ne faut jamais mettre de directive using namespace dans les entêtes: on se retrouve à les imposer à tous les clients de l'entête qui peuvent avoir de bonnes raisons de ne pas les vouloir.
A+
-- Jean-Marc FAQ de fclc++: http://www.cmla.ens-cachan.fr/~dosreis/C++/FAQ C++ FAQ Lite en VF: http://www.ifrance.com/jlecomte/c++/c++-faq-lite/index.html Site de usenet-fr: http://www.usenet-fr.news.eu.org
Gégé <valasg@gmail.com> writes:
Typiquement j'utilise massivement
#include<string>
using namespace std;
Dois-je le mettre dans chaque header?
De mon point de vue, il ne faut jamais mettre de directive using namespace
dans les entêtes: on se retrouve à les imposer à tous les clients de
l'entête qui peuvent avoir de bonnes raisons de ne pas les vouloir.
A+
--
Jean-Marc
FAQ de fclc++: http://www.cmla.ens-cachan.fr/~dosreis/C++/FAQ
C++ FAQ Lite en VF: http://www.ifrance.com/jlecomte/c++/c++-faq-lite/index.html
Site de usenet-fr: http://www.usenet-fr.news.eu.org
De mon point de vue, il ne faut jamais mettre de directive using namespace dans les entêtes: on se retrouve à les imposer à tous les clients de l'entête qui peuvent avoir de bonnes raisons de ne pas les vouloir.
A+
-- Jean-Marc FAQ de fclc++: http://www.cmla.ens-cachan.fr/~dosreis/C++/FAQ C++ FAQ Lite en VF: http://www.ifrance.com/jlecomte/c++/c++-faq-lite/index.html Site de usenet-fr: http://www.usenet-fr.news.eu.org
Fabien LE LEZ
On Sat, 31 Jan 2009 19:09:42 +0100, Jean-Marc Bourguet :
De mon point de vue, il ne faut jamais mettre de directive using namespace dans les entêtes: on se retrouve à les imposer à tous les clients de l'entête qui peuvent avoir de bonnes raisons de ne pas les vouloir.
Et en prime, on se retrouve avec un "using" actif, sans le voir puisqu'il est "caché" dans le .h :-(
On Sat, 31 Jan 2009 19:09:42 +0100, Jean-Marc Bourguet
<jm@bourguet.org>:
De mon point de vue, il ne faut jamais mettre de directive using namespace
dans les entêtes: on se retrouve à les imposer à tous les clients de
l'entête qui peuvent avoir de bonnes raisons de ne pas les vouloir.
Et en prime, on se retrouve avec un "using" actif, sans le voir
puisqu'il est "caché" dans le .h :-(
On Sat, 31 Jan 2009 19:09:42 +0100, Jean-Marc Bourguet :
De mon point de vue, il ne faut jamais mettre de directive using namespace dans les entêtes: on se retrouve à les imposer à tous les clients de l'entête qui peuvent avoir de bonnes raisons de ne pas les vouloir.
Et en prime, on se retrouve avec un "using" actif, sans le voir puisqu'il est "caché" dans le .h :-(
Gégé
Du coup dans la déclaration de mes fonctions il faut que j'utilise std::string ; et dans le cpp je mets un using namespace?
Du coup dans la déclaration de mes fonctions il faut que j'utilise
std::string ; et dans le cpp je mets un using namespace?
Du coup dans la déclaration de mes fonctions il faut que j'utilise std::string ; et dans le cpp je mets un using namespace?
Gégé
les réponses à mes questions sont traités ici http://cpp.developpez.com/faq/cpp/?page=namespace http://www.eventhelix.com/realtimemantra/HeaderFileIncludePatterns.htm
merci
les réponses à mes questions sont traités ici
http://cpp.developpez.com/faq/cpp/?page=namespace
http://www.eventhelix.com/realtimemantra/HeaderFileIncludePatterns.htm
les réponses à mes questions sont traités ici http://cpp.developpez.com/faq/cpp/?page=namespace http://www.eventhelix.com/realtimemantra/HeaderFileIncludePatterns.htm
merci
Etienne Rousee
Gégé a écrit :
Du coup dans la déclaration de mes fonctions
>il faut que j'utilise std::string ;
"string" seulement, si dans le cpp, tu mets le "using namespace std;" avant le "#include ...".
et dans le cpp je mets un using namespace?
Oui, si tu veut éviter le "std::" et que tu ne prévois pas de problèmes de conflits de noms.
--
Etienne
Gégé a écrit :
Du coup dans la déclaration de mes fonctions
>il faut que j'utilise std::string ;
"string" seulement, si dans le cpp, tu mets le
"using namespace std;" avant le "#include ...".
et dans le cpp je mets un using namespace?
Oui, si tu veut éviter le "std::" et que tu ne
prévois pas de problèmes de conflits de noms.
In article <49857132$0$9397$, Etienne Rousee wrote:
Gégé a écrit :
Du coup dans la déclaration de mes fonctions
>il faut que j'utilise std::string ;
"string" seulement, si dans le cpp, tu mets le "using namespace std;" avant le "#include ...".
Mauvais conseil, tres mauvais conseil.
Un fichier d'entetes qui depend de facon aussi directe de la maniere dont il est inclus, c'est une excellente recette pour trouver les emmerdes.
Fabien LE LEZ
On Sun, 1 Feb 2009 10:41:30 +0000 (UTC), (Marc Espie):
Un fichier d'entetes qui depend de facon aussi directe de la maniere dont il est inclus, c'est une excellente recette pour trouver les emmerdes.
Yep. Un en-tête doit être autosuffisant, tout en ayant aussi peu d'effets secondaires que possible.
Donc :
- dans un .h, écrire systématiquement std::string, etc., et ne pas utiliser "using namespace" ni "using std::string".
- dans un .cpp, tu peux, si tu y tiens vraiment, écrire "using namespace std" après le dernier #include. Je me contente quant à moi d'introduire uniquement les noms que j'utilise beaucoup dans ce .cpp. Par exemple : using std::string; using std::vector;
Ces règles obligent à écrire "std::" un peu plus souvent que tu le voudrais, mais évite bien des emmerdes.
On Sun, 1 Feb 2009 10:41:30 +0000 (UTC), espie@lain.home (Marc Espie):
Un fichier d'entetes qui depend de facon aussi directe de la maniere
dont il est inclus, c'est une excellente recette pour trouver les emmerdes.
Yep. Un en-tête doit être autosuffisant, tout en ayant aussi peu
d'effets secondaires que possible.
Donc :
- dans un .h, écrire systématiquement std::string, etc., et ne pas
utiliser "using namespace" ni "using std::string".
- dans un .cpp, tu peux, si tu y tiens vraiment, écrire
"using namespace std" après le dernier #include.
Je me contente quant à moi d'introduire uniquement les noms que
j'utilise beaucoup dans ce .cpp. Par exemple :
using std::string;
using std::vector;
Ces règles obligent à écrire "std::" un peu plus souvent que tu le
voudrais, mais évite bien des emmerdes.
On Sun, 1 Feb 2009 10:41:30 +0000 (UTC), (Marc Espie):
Un fichier d'entetes qui depend de facon aussi directe de la maniere dont il est inclus, c'est une excellente recette pour trouver les emmerdes.
Yep. Un en-tête doit être autosuffisant, tout en ayant aussi peu d'effets secondaires que possible.
Donc :
- dans un .h, écrire systématiquement std::string, etc., et ne pas utiliser "using namespace" ni "using std::string".
- dans un .cpp, tu peux, si tu y tiens vraiment, écrire "using namespace std" après le dernier #include. Je me contente quant à moi d'introduire uniquement les noms que j'utilise beaucoup dans ce .cpp. Par exemple : using std::string; using std::vector;
Ces règles obligent à écrire "std::" un peu plus souvent que tu le voudrais, mais évite bien des emmerdes.
Mickaël Wolff
Fabien LE LEZ a écrit :
- dans un .h, écrire systématiquement std::string, etc., et ne pas utiliser "using namespace" ni "using std::string".
Et en utilisant la technique des namespaces anonymes ça te dérange aussi ?
namespace projet { namespace { using std::string ;
class machin { protected: string nom ;
//... } ; } }
Ça permet d'éviter la pollution du namespace global tout en permettant d'éviter de rendre le code trop lourd à la lecture.
