Privé/public exemple d'en-tête?

Vous avez deux fichiers d'en-tête MyClass.h et MyClass_p.h et un fichier source: MyClass.cpp.

Permet de jeter un oeil à ce qui est à l'intérieur d'eux:

MyClass_p.h:

//Header Guard Here
class MyClassPrivate
{
public:
    int a;
    bool b;
    //more data members;
}

MyClass.h:

//Header Guard Here
class MyClassPrivate;
class MyClass
{
public:
    MyClass();
    ~MyClass();
    void method1();
    int method2();
private:
    MyClassPrivate* mData;
}

MyClass.cpp:

#include "MyClass.h"
#include "MyClass_p.h"

MyClass::MyClass()
{
    mData = new MyClassPrivate();
}

MyClass::~MyClass()
{
    delete mData;
}

void MyClass::method1()
{
    //do stuff
}

int MyClass::method2()
{
    return stuff;
}

Garder vos données en MyClassPrivate et distribuer MyClass.h.

En fait, j'ai trouvé les deux à en-tête d'une source d'approche à être fragile. Si vous avez oublié de mettre à jour le "public" à la tête à la suite de changer le "privé" de l'en-tête, votre code peut compiler, puis erreur quelque part d'autre au moment de l'exécution. J'ai eu cela m'arrive à moi un peu de temps, donc je préfère écrire du code qui ne compile pas moins que tout est correct.

MyClass.cpp est mis en œuvre comme ceci:

#define MYCLASS_IMPL
#include "MyClass.h"

//Implementation follows
...

MyClass.h est le morceau intéressant:

#ifdef MYCLASS_IMPL
#include everything needed for the private: section
#endif

#include everything needed for the public: section only

class MyClass
{
public:
    //Everything that's public

#ifdef MYCLASS_IMPL
private:

    //Implementation details

#endif
};

Si le but est de cacher les détails d'implémentation (par exemple, une bibliothèque fermée), vous devrez peut-être aller avec les deux en-tête de l'approche. Si vous ne voulez pas faire glisser dans les dépendances d'utiliser une classe, le seul en-tête de l'approche peut être une solution simple et robuste.

À l'adresse Arton à la question: Il a été un moment depuis que j'ai regardé, mais je pense que la question a à voir avec l'instanciation des objets en se basant sur l'en-tête public, puis en supposant un autre objet de taille avec l'en-tête. Au moment de l'exécution, un décalage de l'objet ne correspond pas, provoquant un mémoire smash. Il semble que erenlender la réponse de couvre ce cas, avec un public/privé de la classe paire.

Je me demandais la même chose depuis que je suis passer de C à C++ comme mon principal langage de programmation. Je suppose que la meilleure façon est d'utiliser des interfaces (les classes abstraites en C++): vous publiez une interface publique et privée de la mise en œuvre suffit d'utiliser l'interface de la classe de base.