Automatize o Pimpl'ing de classes C ++ - existe uma maneira fácil?

Question

O PIMPL's é uma fonte de caldeira em muitos código C ++. Eles parecem o tipo de coisa que uma combinação de macros, modelos e talvez uma pequena ajuda externa da ferramenta poderia resolver, mas não tenho certeza de qual seria o caminho mais fácil. Eu já vi modelos Isso ajuda a fazer parte do levantamento, mas não muito - você ainda precisa escrever funções de encaminhamento para todos os métodos da classe que você está tentando embrulhar. Existe uma maneira mais fácil?

Estou imaginando uma ferramenta usada como parte do processo de criação. Você deseja que seus cabeçalhos públicos sejam aulas Pimpl'd, para fornecer algum arquivo de entrada, digamos Pimpl.in, que lista as classes (implementadas un-Pimpl'd) que você gostaria de envolver, então esse arquivo é examinado, As classes PIMPL são geradas e apenas seus cabeçalhos (não os cabeçalhos da classe original) são instalados durante uma 'Make Install'. O problema é que não vejo nenhuma maneira de fazer isso sem um analisador C ++ completo, algo que mesmo os fornecedores do compilador não podem acertar. Talvez as aulas possam ser escritas de alguma forma que facilitem o trabalho de uma ferramenta externa, mas tenho certeza de que acabarei perdendo todos os tipos de casos de canto (por exemplo, aulas modeladas e/ou funções de membros modeladas).

Alguma ideia? Alguém já veio com uma solução para esse problema?

Answer 1

Não, não há uma resposta fácil. :-( Eu pensaria que, com quase todos os especialistas em OO dizendo "preferem composição à herança", haveria suporte ao idioma para facilitar muito a composição do que a herança.

Answer 2

Não estou dizendo que isso é bom (apenas algo que surgiu à mente).
Mas você pode experimentar sobrecarregar o operador ->

#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

Uma opção é usar uma classe de interface:

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

// in ClassA.cpp

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

No entanto, isso adiciona sobrecarga de buscar os ponteiros da função vtable.

Fora isso, não consigo pensar em nenhuma ferramenta. Como você disse, a análise C ++ não é trivial, e existem outros idiomas por aí onde é menos um problema (por exemplo, C# ou Java Tard-Bind tudo, para que você possa alterar o layout da memória posteriormente sem problemas).