c++ - Implementando pImpl con cantidad mínima de código

boost pimpl-idiom

Question

¿Qué tipo de trucos se pueden utilizar para minimizar la carga de trabajo de implementar clases de pImpl?

Encabezamiento:

class Foo {
    struct Impl;
    boost::scoped_ptr<Impl> self;
public:
    Foo(int arg);
    ~Foo();
    // Public member functions go here
};

Implementación:

struct Foo::Impl {
    Impl(int arg): something(arg) {}
    // All data members and private functions go here
};

Foo::Foo(int arg): self(new Impl(arg)) {}
Foo::~Foo() {}

// Foo''s public functions go here (and they refer to data as self->something)

¿Cómo mejoraría esto, usando Boost, posiblemente herencia, CRTP u otros trucos para evitar tanto código repetitivo como sea posible? El rendimiento del tiempo de ejecución no es un problema.

Answer 1

Es posible, pero una implementación ingenua no es lo que quieres.

El problema es que las plantillas generalmente están en línea, la implementación ingenua sería:

template <class Object>
class Pimpl
{
public:
  explicit Pimpl(Object* obj): mObject(obj) {}
  ~Pimpl() { delete mObject; }

  // either deep copy or no copy
private:
  Object* mObject;
};

Ahora el problema es que no quiere que Object se conozca en su archivo de encabezado en general (no para compatibilidad binaria, sino para administración de dependencias). Y si no se conoce el objeto, entonces no se puede implementar Destructor , Copy Constructor y Assignment Operator directamente ...

¡El problema está lejos de ser insoluble sin embargo! Boost de hecho lo ha resuelto para shared_ptr .

La idea es pasar un segundo elemento en el constructor, que se encargará de liberar la memoria del primero, y que se le proporcionará una buena implementación predeterminada.

Esto funciona con una indirección, por supuesto.

namespace detail {
  template <class Object>
  struct Deleter { virtual void do(Object*) = 0; };
}

template <class Object>
class Pimpl
{
public:
  typedef detail::Deleter<Object> deleter_type;
  typedef boost::shared_ptr<deleter_type> deleter_pointer;

  Pimpl(std::auto_ptr<Object> obj, deleter_pointer del);
  ~Pimpl();
  Pimpl(const Pimpl&);
  Pimpl& operator(const Pimpl&);

private:
  Object* mObject;
  deleter_pointer mDeleter;
};

Es un modismo clásico en C ++, agrega otro nivel de indirección :)

Answer 2

La implementación de pimpl de Loki puede ser una buena respuesta. Ver también un artículo de DDJ sobre esto.