A priori, j'aurais mis les #include dans le .h plutôt que dans le .cpp
(chose que j'ai l'habitude de faire en C).
J'aurais alors peut-être eu besoin de répéter l'include de <list> dans
chacun des .h, mais le but n'est-il pas justement de mettre dans ce fichier
tout ce qui est nécessaire au .cpp, autre que le code ?
A priori, j'aurais mis les #include dans le .h plutôt que dans le .cpp
(chose que j'ai l'habitude de faire en C).
J'aurais alors peut-être eu besoin de répéter l'include de <list> dans
chacun des .h, mais le but n'est-il pas justement de mettre dans ce fichier
tout ce qui est nécessaire au .cpp, autre que le code ?
A priori, j'aurais mis les #include dans le .h plutôt que dans le .cpp
(chose que j'ai l'habitude de faire en C).
J'aurais alors peut-être eu besoin de répéter l'include de <list> dans
chacun des .h, mais le but n'est-il pas justement de mettre dans ce fichier
tout ce qui est nécessaire au .cpp, autre que le code ?
"Jean-Noël Mégoz" writes:A priori, j'aurais mis les #include dans le .h plutôt que dans le .cpp
(chose que j'ai l'habitude de faire en C).
Ce n'est pas une super habitude ...
[...]
En particulier, si un jour tu as des dépendances croisées
A.h B.h
^ / ^
| X |
| / |
A.cpp B.cpp
Tu ne pourra pas faire autrement sous peine de dépendances cycliques.
Maintenant que tu le dis, je comprends mon erreur.
"Jean-Noël Mégoz" <nospam_jnmegoz@infonie.fr> writes:
A priori, j'aurais mis les #include dans le .h plutôt que dans le .cpp
(chose que j'ai l'habitude de faire en C).
Ce n'est pas une super habitude ...
[...]
En particulier, si un jour tu as des dépendances croisées
A.h B.h
^ / ^
| X |
| / |
A.cpp B.cpp
Tu ne pourra pas faire autrement sous peine de dépendances cycliques.
Maintenant que tu le dis, je comprends mon erreur.
"Jean-Noël Mégoz" writes:A priori, j'aurais mis les #include dans le .h plutôt que dans le .cpp
(chose que j'ai l'habitude de faire en C).
Ce n'est pas une super habitude ...
[...]
En particulier, si un jour tu as des dépendances croisées
A.h B.h
^ / ^
| X |
| / |
A.cpp B.cpp
Tu ne pourra pas faire autrement sous peine de dépendances cycliques.
Maintenant que tu le dis, je comprends mon erreur.
La solution proposée ici est-elle équivalente/meilleure/la seule
envisageable ?
La solution proposée ici est-elle équivalente/meilleure/la seule
envisageable ?
La solution proposée ici est-elle équivalente/meilleure/la seule
envisageable ?
- ceux qui considere qu'un fichier ne contenant que
#include "foo.hxx"
doit pouvoir compiler quel que soit foo.hxx
- ceux qui considere qu'un fichier ne contenant que
#include "foo.hxx"
doit pouvoir compiler quel que soit foo.hxx
- ceux qui considere qu'un fichier ne contenant que
#include "foo.hxx"
doit pouvoir compiler quel que soit foo.hxx
Bonjour,
Je potasse actuellement un cours de C++ et je viens de réaliser un truc qui
me chiffonne dans un exemple :
-- Book.h -------------------------------------
#ifndef BOOK_H
#define BOOK_H
class Reader;
class Reservation;
class Book
{
friend class Reservation;
private:
list<Reservation*> reserv;
[...]
public:
[...]
};
#endif
-- Book.cpp -----------------------------------
#include <list>
using namespace std;
#include "Reader.h"
#include "Book.h"
#include "Reservation.h"
[...]
-----------------------------------------------
Bonjour,
Je potasse actuellement un cours de C++ et je viens de réaliser un truc qui
me chiffonne dans un exemple :
-- Book.h -------------------------------------
#ifndef BOOK_H
#define BOOK_H
class Reader;
class Reservation;
class Book
{
friend class Reservation;
private:
list<Reservation*> reserv;
[...]
public:
[...]
};
#endif
-- Book.cpp -----------------------------------
#include <list>
using namespace std;
#include "Reader.h"
#include "Book.h"
#include "Reservation.h"
[...]
-----------------------------------------------
Bonjour,
Je potasse actuellement un cours de C++ et je viens de réaliser un truc qui
me chiffonne dans un exemple :
-- Book.h -------------------------------------
#ifndef BOOK_H
#define BOOK_H
class Reader;
class Reservation;
class Book
{
friend class Reservation;
private:
list<Reservation*> reserv;
[...]
public:
[...]
};
#endif
-- Book.cpp -----------------------------------
#include <list>
using namespace std;
#include "Reader.h"
#include "Book.h"
#include "Reservation.h"
[...]
-----------------------------------------------
"Jean-Noël Mégoz" writes:La solution proposée ici est-elle équivalente/meilleure/la seule
envisageable ?
Il y a deux ecoles
- ceux qui ne mettent aucun #include dans un .hxx
- ceux qui considere qu'un fichier ne contenant que
#include "foo.hxx"
doit pouvoir compiler quel que soit foo.hxx
Je fais partie de la seconde -- et plus je touche des projets ou des
gens de la premiere ont sevi, plus je suis convaincu que ma position
est la bonne.
"Jean-Noël Mégoz" <nospam_jnmegoz@infonie.fr> writes:
La solution proposée ici est-elle équivalente/meilleure/la seule
envisageable ?
Il y a deux ecoles
- ceux qui ne mettent aucun #include dans un .hxx
- ceux qui considere qu'un fichier ne contenant que
#include "foo.hxx"
doit pouvoir compiler quel que soit foo.hxx
Je fais partie de la seconde -- et plus je touche des projets ou des
gens de la premiere ont sevi, plus je suis convaincu que ma position
est la bonne.
"Jean-Noël Mégoz" writes:La solution proposée ici est-elle équivalente/meilleure/la seule
envisageable ?
Il y a deux ecoles
- ceux qui ne mettent aucun #include dans un .hxx
- ceux qui considere qu'un fichier ne contenant que
#include "foo.hxx"
doit pouvoir compiler quel que soit foo.hxx
Je fais partie de la seconde -- et plus je touche des projets ou des
gens de la premiere ont sevi, plus je suis convaincu que ma position
est la bonne.
Jean-Marc Bourguet wrote in message
news:..."Jean-Noël Mégoz" writes:La solution proposée ici est-elle équivalente/meilleure/la seule
envisageable ?
Il y a deux ecoles
- ceux qui ne mettent aucun #include dans un .hxx
- ceux qui considere qu'un fichier ne contenant que
#include "foo.hxx"
doit pouvoir compiler quel que soit foo.hxx
Je fais partie de la seconde -- et plus je touche des projets ou des
gens de la premiere ont sevi, plus je suis convaincu que ma position
est la bonne.
Je crois que de nos jours, il s'est fait un consensus pour la
seconde.
Pour la reste, j'avoue ne jamais avoir eu à travailler avec du code de
la première école. Quand ce n'était pas la seconde école, c'était à peu
près n'importe quoi.
Ceci dit, ce n'est pas toujours évident à enforcer la seconde école.
Pour prendre un exemple un peu bête, si j'écris une classe qui
dérive de std::streambuf, et qui contient un membre de type
std::string, je dois logiquement inclure et <streambuf> et
<string>. Or, il y a des implémentations où <streambuf> inclut
<string> déjà, ce qui veut dire que si j'oublis <string>, l'en-tête
va compiler quand même tout seul. Jusqu'à ce que je porte à une
autre implémentation.
Jean-Marc Bourguet <jm@bourguet.org> wrote in message
news:<pxbfzbf956y.fsf@news.bourguet.org>...
"Jean-Noël Mégoz" <nospam_jnmegoz@infonie.fr> writes:
La solution proposée ici est-elle équivalente/meilleure/la seule
envisageable ?
Il y a deux ecoles
- ceux qui ne mettent aucun #include dans un .hxx
- ceux qui considere qu'un fichier ne contenant que
#include "foo.hxx"
doit pouvoir compiler quel que soit foo.hxx
Je fais partie de la seconde -- et plus je touche des projets ou des
gens de la premiere ont sevi, plus je suis convaincu que ma position
est la bonne.
Je crois que de nos jours, il s'est fait un consensus pour la
seconde.
Pour la reste, j'avoue ne jamais avoir eu à travailler avec du code de
la première école. Quand ce n'était pas la seconde école, c'était à peu
près n'importe quoi.
Ceci dit, ce n'est pas toujours évident à enforcer la seconde école.
Pour prendre un exemple un peu bête, si j'écris une classe qui
dérive de std::streambuf, et qui contient un membre de type
std::string, je dois logiquement inclure et <streambuf> et
<string>. Or, il y a des implémentations où <streambuf> inclut
<string> déjà, ce qui veut dire que si j'oublis <string>, l'en-tête
va compiler quand même tout seul. Jusqu'à ce que je porte à une
autre implémentation.
Jean-Marc Bourguet wrote in message
news:..."Jean-Noël Mégoz" writes:La solution proposée ici est-elle équivalente/meilleure/la seule
envisageable ?
Il y a deux ecoles
- ceux qui ne mettent aucun #include dans un .hxx
- ceux qui considere qu'un fichier ne contenant que
#include "foo.hxx"
doit pouvoir compiler quel que soit foo.hxx
Je fais partie de la seconde -- et plus je touche des projets ou des
gens de la premiere ont sevi, plus je suis convaincu que ma position
est la bonne.
Je crois que de nos jours, il s'est fait un consensus pour la
seconde.
Pour la reste, j'avoue ne jamais avoir eu à travailler avec du code de
la première école. Quand ce n'était pas la seconde école, c'était à peu
près n'importe quoi.
Ceci dit, ce n'est pas toujours évident à enforcer la seconde école.
Pour prendre un exemple un peu bête, si j'écris une classe qui
dérive de std::streambuf, et qui contient un membre de type
std::string, je dois logiquement inclure et <streambuf> et
<string>. Or, il y a des implémentations où <streambuf> inclut
<string> déjà, ce qui veut dire que si j'oublis <string>, l'en-tête
va compiler quand même tout seul. Jusqu'à ce que je porte à une
autre implémentation.
Mais par contre, la classe a besoin d'utiliser list (std::list ?), et
j'ajouterai un #include <list>.
Enfin, ce .h suppose l'utilisation d'un using namespace, ce qui est moche.
Mais par contre, la classe a besoin d'utiliser list (std::list ?), et
j'ajouterai un #include <list>.
Enfin, ce .h suppose l'utilisation d'un using namespace, ce qui est moche.
Mais par contre, la classe a besoin d'utiliser list (std::list ?), et
j'ajouterai un #include <list>.
Enfin, ce .h suppose l'utilisation d'un using namespace, ce qui est moche.
Ceci dit, ce n'est pas toujours évident à enforcer la seconde école.
Pour prendre un exemple un peu bête, si j'écris une classe qui dérive de
std::streambuf, et qui contient un membre de type std::string, je dois
logiquement inclure et <streambuf> et <string>. Or, il y a des
implémentations où <streambuf> inclut <string> déjà, ce qui veut dire
que si j'oublis <string>, l'en-tête va compiler quand même tout seul.
Jusqu'à ce que je porte à une autre implémentation.
Ceci dit, ce n'est pas toujours évident à enforcer la seconde école.
Pour prendre un exemple un peu bête, si j'écris une classe qui dérive de
std::streambuf, et qui contient un membre de type std::string, je dois
logiquement inclure et <streambuf> et <string>. Or, il y a des
implémentations où <streambuf> inclut <string> déjà, ce qui veut dire
que si j'oublis <string>, l'en-tête va compiler quand même tout seul.
Jusqu'à ce que je porte à une autre implémentation.
Ceci dit, ce n'est pas toujours évident à enforcer la seconde école.
Pour prendre un exemple un peu bête, si j'écris une classe qui dérive de
std::streambuf, et qui contient un membre de type std::string, je dois
logiquement inclure et <streambuf> et <string>. Or, il y a des
implémentations où <streambuf> inclut <string> déjà, ce qui veut dire
que si j'oublis <string>, l'en-tête va compiler quand même tout seul.
Jusqu'à ce que je porte à une autre implémentation.
writes:Jean-Marc Bourguet wrote in message
news:..."Jean-Noël Mégoz" writes:La solution proposée ici est-elle équivalente/meilleure/la seule
envisageable ?
Il y a deux ecoles
- ceux qui ne mettent aucun #include dans un .hxx
- ceux qui considere qu'un fichier ne contenant que
#include "foo.hxx"
doit pouvoir compiler quel que soit foo.hxx
Je fais partie de la seconde -- et plus je touche des projets ou
des gens de la premiere ont sevi, plus je suis convaincu que ma
position est la bonne.
Je crois que de nos jours, il s'est fait un consensus pour la
seconde.
J'ai des collegues membres farouches de la premiere avec suffisemment
d'autorite pour l'imposer dans leur projet. Heureusement ce n'est pas
le mien... :-)
Pour la reste, j'avoue ne jamais avoir eu à travailler avec du code
de la première école. Quand ce n'était pas la seconde école, c'était
à peu près n'importe quoi.
Reellement n'importe quoi j'ai pas vu. Mais du code des gens de la
premiere modifie par des gens qui n'ont pas pris l'initiative de
passer clairement a la seconde, ca oui. Generalement j'ajoute alors
les en-tetes qu'il faut a la premiere occasion.
Ceci dit, ce n'est pas toujours évident à enforcer la seconde école.
Pour prendre un exemple un peu bête, si j'écris une classe qui
dérive de std::streambuf, et qui contient un membre de type
std::string, je dois logiquement inclure et <streambuf> et <string>.
Or, il y a des implémentations où <streambuf> inclut <string> déjà,
ce qui veut dire que si j'oublis <string>, l'en-tête va compiler
quand même tout seul. Jusqu'à ce que je porte à une autre
implémentation.
Tu peux avoir exactement le meme probleme en etant de la premiere
ecole, a part que pour le fixer tu devras modifier 1234 fichiers.
kanze@gabi-soft.fr writes:
Jean-Marc Bourguet <jm@bourguet.org> wrote in message
news:<pxbfzbf956y.fsf@news.bourguet.org>...
"Jean-Noël Mégoz" <nospam_jnmegoz@infonie.fr> writes:
La solution proposée ici est-elle équivalente/meilleure/la seule
envisageable ?
Il y a deux ecoles
- ceux qui ne mettent aucun #include dans un .hxx
- ceux qui considere qu'un fichier ne contenant que
#include "foo.hxx"
doit pouvoir compiler quel que soit foo.hxx
Je fais partie de la seconde -- et plus je touche des projets ou
des gens de la premiere ont sevi, plus je suis convaincu que ma
position est la bonne.
Je crois que de nos jours, il s'est fait un consensus pour la
seconde.
J'ai des collegues membres farouches de la premiere avec suffisemment
d'autorite pour l'imposer dans leur projet. Heureusement ce n'est pas
le mien... :-)
Pour la reste, j'avoue ne jamais avoir eu à travailler avec du code
de la première école. Quand ce n'était pas la seconde école, c'était
à peu près n'importe quoi.
Reellement n'importe quoi j'ai pas vu. Mais du code des gens de la
premiere modifie par des gens qui n'ont pas pris l'initiative de
passer clairement a la seconde, ca oui. Generalement j'ajoute alors
les en-tetes qu'il faut a la premiere occasion.
Ceci dit, ce n'est pas toujours évident à enforcer la seconde école.
Pour prendre un exemple un peu bête, si j'écris une classe qui
dérive de std::streambuf, et qui contient un membre de type
std::string, je dois logiquement inclure et <streambuf> et <string>.
Or, il y a des implémentations où <streambuf> inclut <string> déjà,
ce qui veut dire que si j'oublis <string>, l'en-tête va compiler
quand même tout seul. Jusqu'à ce que je porte à une autre
implémentation.
Tu peux avoir exactement le meme probleme en etant de la premiere
ecole, a part que pour le fixer tu devras modifier 1234 fichiers.
writes:Jean-Marc Bourguet wrote in message
news:..."Jean-Noël Mégoz" writes:La solution proposée ici est-elle équivalente/meilleure/la seule
envisageable ?
Il y a deux ecoles
- ceux qui ne mettent aucun #include dans un .hxx
- ceux qui considere qu'un fichier ne contenant que
#include "foo.hxx"
doit pouvoir compiler quel que soit foo.hxx
Je fais partie de la seconde -- et plus je touche des projets ou
des gens de la premiere ont sevi, plus je suis convaincu que ma
position est la bonne.
Je crois que de nos jours, il s'est fait un consensus pour la
seconde.
J'ai des collegues membres farouches de la premiere avec suffisemment
d'autorite pour l'imposer dans leur projet. Heureusement ce n'est pas
le mien... :-)
Pour la reste, j'avoue ne jamais avoir eu à travailler avec du code
de la première école. Quand ce n'était pas la seconde école, c'était
à peu près n'importe quoi.
Reellement n'importe quoi j'ai pas vu. Mais du code des gens de la
premiere modifie par des gens qui n'ont pas pris l'initiative de
passer clairement a la seconde, ca oui. Generalement j'ajoute alors
les en-tetes qu'il faut a la premiere occasion.
Ceci dit, ce n'est pas toujours évident à enforcer la seconde école.
Pour prendre un exemple un peu bête, si j'écris une classe qui
dérive de std::streambuf, et qui contient un membre de type
std::string, je dois logiquement inclure et <streambuf> et <string>.
Or, il y a des implémentations où <streambuf> inclut <string> déjà,
ce qui veut dire que si j'oublis <string>, l'en-tête va compiler
quand même tout seul. Jusqu'à ce que je porte à une autre
implémentation.
Tu peux avoir exactement le meme probleme en etant de la premiere
ecole, a part que pour le fixer tu devras modifier 1234 fichiers.