Bonjour,

J'ai actuellement une classe définie comme suit :

foo.h

Et un fichier bar.cpp qui utilise ma classe Foo :

Le problème est que je dois également inclure la déclaration de la classe FooPriv dans bar.cpp, chose que je ne veux pas.

Ce que je veux, c'est qu'en incluant foo.h, bar.cpp ne "voit" que l'interface de ma classe Foo, et pas les éventuelles variables privées qu'elle peut utiliser pour faire sa cuisine.

Est-ce qu'il existe une technique pour éviter ce genre de désagrément ?

Aucune raison de le faire, sinon c'ets que tu t'es vautré avant.

et genre foo.h inclue pas foo_priv.h ???

je vois pas le rapport o_O

Cacher l'implémentation, ok ! Mais là il est question de cacher l'interface si j'ai bien compris.

Oui mais non. Le problème sera de toute façon le même. Quand j'incluerai foo.h à partir de bar.cpp, le compilo dira qu'il ne connait pas la classe FooPriv.
 

Justement non.

Pour reprendre et essayer d'être plus clair, je dispose des 3 fichiers suivants :
 
foo.h qui déclare la classe Foo (ce fichier ne comporte pas d'autre code, et plus particulièrement : il n'inclut pas foo_priv.h)

 
foo_priv.h qui déclare la classe FooPriv (ce fichier ne comporte pas d'autre code)

 
Et un fichier bar.cpp qui utilise ma classe Foo :

 
Bien sûr en l'état actuel, ça ne peut pas compiler correctement.
On part du principe que bar.cpp n'a aucune raison de connaître la classe FooPriv.
Du coup comment dois-je me débrouiller ?

inclure fooPriv.h dans foo.h !
Tu cherches à faire ou à masquer quelque chose en particulier ? Parce que sinon, je ne vois pas le problème !

Si dans foo.h, tu n'inclues pas foo_priv.h, cela ne compileras pas (et cela n'a rien à voir avec le code dans bar.cpp), le compilateur a besoine de connaître la taille de l'objet FooPriv pour connaître la taille à allouer pour Foo.
 
Si tu ne veux pas inclure foo_priv.h dans foo.h, la solution proposée par Drizzt_dOo_urden (FooPriv*) est la bonne dans ce cas (où utiliser des smart pointers). Sinon tu n'a pas le choix, tu dois obligatoirement inclure foo_priv.h dans foo.h.

Effectivement, tu as complètement raison. Merci beaucoup
 
 
Mais par contre, est-ce qu'il y a une solution pour les variables qui ne sont pas des pointeurs ?

Hein ?

 
et pas

Ben, ça ne change rien ! C'est pareil !!
 
Faudrait que tu revois les bases là quand même !

T'es sûr que c'est pareil?
Moi je dirais que mr simon a raison.
 

Mais du moment que tu inclues foo_priv.h dans foo.h, le compilo, il connait la taille de l'objet !
Après, que tu déclares un pointeur ou une variable, ça ne change strictement rien !

 
Bah çà change un peu quand même. Si tu as une classe avec beaucoup de membres nécessitant beaucoup d'include, à chaque fois que tu voudras utiliser l'objet Foo, et donc que tu inclues foo.h, le compilo va analyser tout les points .h, et çà peut rallonger, significativement, le temps de compilation.
Ceci est surtout vrai pour des grosses librairies (type boost).
 
D'autre part, si foo_priv.h est souvent modifié, alors tout les fichiers incluant foo.h seront recompilés. Donc je dirais qu'il faut peser le pour et le contre entre utiliser un objet ou une pointer sur cet objet (utilisation de smart pointer).

salut, tu peux faire une interface qui expose ce que tu veux exposer de Foo
une implémentation de Foo qui contient ce que tu veux 'cacher'
(c'est le but des interfaces [classes abstraites])
 
le CPP qui va faire l'instanciation de Foo_impl devra inclure le .H 'complet' de Foo_impl
les autres juste le .H de l'interface
 
IFoo.h
---
class IFoo
{
  protected:
    IFoo();
    virtual ~IFoo();
  public:
    virtual void DoSmthg() = 0;
};
---
 
Foo.h
---
#include "IFoo.h"
#include "pouet.H"
class Foo: public IFoo
{
  public:
    Foo();
    ~Foo();
    void DoSmthg();
  private:
    pouet m_pouet;
};
---
 
fichier qui instancie.cpp
---
#include "Foo.h" // du lourd
Foo * toto = new Foo();
---
 
fichier qui utilise.cpp
---
#include "IFoo.h" // léger
void func(IFoo * object)
{
   objet->DoSmthg();
}

Mais, de toute façon, que ce soit pour déclarer un pointeur ou un objet, il faut inclure foo_priv.h !
Donc que tu déclare un pionteur ou un objet, ça ne change strictement rien concernant la compilation ou l'inclusion de ton .h !
 
Pis, optimiser le temps de compilation ... y'a plus important avant d'en arriver là quand même !

Bah non justement, si tu as simplement un pointeur, tu n'inclues pas le .h mais tu déclare juste la classe:

.
 
Certe il y a plus important, mais quand tu as une application conséquente, gagner quelques minutes (voir plusieurs) n'est pas négligeable.

Ho pinaise. Je viens de relire avec le doit depuis le début, j'étais complètement à côté de la plaque.
Désolé !  

En fait j'ai une contrainte de programmation qui m'interdit d'inclure des .h dans des .h. On peut trouver ça con, mais c'est comme ça ; j'ai pas le choix.
Du coup à chaque fois que j'inclus foo.h, je dois aussi inclure les .h dont dépend foo.h.
 
De plus, ça me pose un problème de conscience ( ) que les fichiers qui incluent foo.h voient les modules que peut utiliser pour sa cuisine perso la classe Foo.

J'aimerais bien savoir pourquoi (sans rire)
 

PIMPL ou Handle-Body et voila

On m'avait donné l'explication, mais j'étais pas du tout convaincu. Là je m'en rappelle plus.
 

Cool, merci.

Tiens à ce propos:  
 
http://www.gotw.ca/gotw/028.htm