dans le effective C++ de scot meyers je ne comprend pas comment il fais dans le chapitre intitulé "minimisez les dependances et compilation entre fichier"
 
qu'entend t'il dans son exemple par  //pointeur sur l'implementation
 
du code de l'exemple Person  
 
il declare une classe PersonImpl ;   (non fournie dans l'exemple)
et je vois pas a quoi elle peut resembler    
si kkn peux m'aider ca serrais cool  

classe.hpp : délcaration anticipée de la classe Implementation. Ben comme membre dans ta classe y a que Implementation *pimpl;
 
classe.cpp : include "implementation.hpp" et utilisation simple genre pimpl->foo()
 
main.cpp : include "classe.hpp"
 
maintenant, si tu modifies implementation.[ch]pp, ni classe.cpp ni main.cpp n'ont besoin d'être recompiler
 

 
oui mais  comment tu affecte le pointeur de la classe implementation a la classe personne c'est ce que je saisit pas
 
car il a une classe personne qui contiens un pointeur sur une classe impelmentation  
 
mais l'implementation et la classe personnes son 2 classe distincts
dans ce que jai compris donc on peux pas faire
 implementation->methode_de_la classe_personne()  
 

si je te fais un .tar tu me fiche la paix ?

 
  faché ?
ben si tu a un exemple complet oui ca m'interesserais car je suis sur que c'est tout con    

non, mais là aujourd'hui j'ai plus le temps

ca presse pas

 
Tu fais cela dans le constructeur, mais là ca n'a plus d'importance car le code du constructeur se trouve dans le .cxx et non dans le header et le but est de reduire les dependances etre header.
 
Imagine que tu soit en train de fiare une shared-library (ou une Dll) a vendre a un client : tu cherches a faire des .hxx les plus conpacts et evitant de lui donner toutes tes structures...
 

Il faut tout de meme noter que meme si le nom du bouquin c'est
"effective C++", c'est un schema a éviter en regle general.
 
Mais comme on dit ça peut toujours servir..
 
LeGreg

mais comme dit dans le livre
ty perd en rap d'exec
mais tu y gagne en temps de compil
non?

tu perds 3 fois rien en exec, une indirection, y a pas de quoi fouetter un chat

donc c'est interessant ?

si t'en as besoin oui

 
La perte en vitesse d'execution est difficile a évaluer...
cela depend des chemin d'appels que tu prends : si tu n'appelles les dites fonctions qu'une fois dans le prog... effectivement les pertes seront invisibles
 
par contre s'il y a de nombreux appels via cette indirection le cout augmente...  
Avec les proc modernes qui tournent bcp plus vite que la mémoire, qui ont des memoire rapides en débit mais avec des temps de latence médiocres...   enfin bref en abuser avec un P4 peut finir par avoir un effet...

 
ben perso je cherche a diminuer le temps de compil car la
bien que le projet soit pas gargantuesque ,
 viva les pauses café a chaque recompil donc je me suis dis tien pourquoi aps apliquer cela ca ma lair plutot sympa et ingenieux
apres effectivemnt faudrais que je fasse un bech pour voir si j'y perd tant que ca en exec

ça veut dire quoi long ? t'es sur de déjà savoir bien de servir des #include ?

 
qu'entend tu par la ?  
 
mis a part eviter les double reinclusions et inclure seulement les fichiers necessaire pour compiler la classe je ne fais rien de special au niveau des includes (si je les mets tous dans le .hh)  

l'erreur la plus commune, c'est de foutre tous les #include dans le .h, et dans le .c, include le dit .h et rien d'autres.
 
avant de tout reconstruire, t'as essayé de te tourner vers d'autres solutions peut être plus simple à mettre en action ? je sais pas moi, genre ccache ?

Precompiled header par exemple.
 
Sinon une solution qui marche bien c'est
de faire un gros fichier.cpp à partir de tous les petits .cpp
à la compilation ("cat" ou un truc du genre) et de lancer la compile. C'est la plus rapide pour une compilation "from scratch". Enfin certains compilos vont avoir des problemes avec les TRES gros sources (arrivé sur mon précédent projet) mais si c'est bien segmenté ça passe.

avec gcc y a pas mal de bêtises à faire, à commencer par le -pipe et après lancer make -jN

Il y a une discussion de pimpl et de "fast pimpl" sur le site de Herb Sutter :  
http://www.gotw.ca/gotw/024.htm
http://www.gotw.ca/gotw/028.htm
(au passage, l'article sur les Smart pointer members est plus intéressant)
 
Mais effectivement, avant de recourir à ce genre de bidouilles, la première chose à faire est de supprimer un maximum de #include des .h et de déclarer les classes nécessaires à la compile à la place d'include dans les .h
 
Faire:
class machin;
class chose;
 
plutot que :
#include "machin.h"
#include "chose.h"
 
Après étudier les options qu'offrent le compilo. Enfin, la méthode de LeGreg (que je ne connaissais pas) semble assez astucieuse si les header précompilés n'existent pas avec ton compilo.  
 
Mais le mieux si tu as la chance d'avoir un PC multiprocesseur (ou un réseau), est d'essayer l'outil gratuit jam à la place de make : il trouve les dépendances tout seul à partir des fichiers source (plus besoin de les spécifier), et il répartit les compilations sur les différents processeurs en tenant compte des dépendances.
 
http://www.perforce.com/jam/jam.html

Dans le même genre que jam, je viens de découvrir Cmake :
http://www.cmake.org
 
Pas essayé, mais ça a l'air pas mal.

pitié !
 
www.scons.org

???

ben essaie donc scons