Automatiser le pimplage des classes C ++ - existe-t-il un moyen simple?

Question

Les Pimpl sont une source de passe-partout dans beaucoup de code C ++. Cela semble être le genre de choses qu'une combinaison de macros, de modèles et peut-être d'un petit outil d'aide externe pourrait résoudre, mais je ne sais pas quel serait le moyen le plus simple.

Était-ce utile?

Nous faire parvenir

La solution

Non, il n’ya pas de réponse facile. :-( Je pense qu'avec presque tous les experts OO disant "préférez la composition à l'héritage", il existe un support linguistique pour rendre la composition beaucoup plus facile que l'héritage.

Answer 1

Non, il n’ya pas de réponse facile. :-( Je pense qu'avec presque tous les experts OO disant "préférez la composition à l'héritage", il existe un support linguistique pour rendre la composition beaucoup plus facile que l'héritage.

Answer 2

Je ne dis pas que c'est bon (juste quelque chose qui me vient à l'esprit).
Mais vous pouvez essayer de surcharger l’opérateur - >

#include <memory>
#include <iostream>

class X
{
    public:
    void plop()
    {
        std::cout << "Plop\n";
    }
};

class PimplX
{
    public:
        PimplX()
        {
            pimpl.reset(new X);
        }
        X* operator->()
        {
            return pimpl.get();
        }
    private:
        PimplX(PimplX const&);
        PimplX& operator=(PimplX const&);
        std::auto_ptr<X>    pimpl;
};   


int main()
{    
    PimplX      x;

    x->plop();
}

Answer 3

Une option consiste à utiliser une classe d'interface à la place:

class ClassA {
  virtual void foo() = 0;
  static ClassA *create();
};

// in ClassA.cpp

class ImplA : public ClassA {
/* ... */
};
ClassA *ClassA::create() {
  return new ImplA();
}

Ceci ajoute cependant un temps d’argent de la récupération des pointeurs de la fonction vtable.

Autre que cela, je ne peux pas penser à un tel outil. Comme vous l'avez dit, l'analyse de C ++ n'est pas triviale, et il existe d'autres langages qui posent moins de problèmes (par exemple, tout lier tardivement en C # ou en Java, afin que vous puissiez modifier leur disposition en mémoire plus tard sans problème).