¿Cuáles son los pros y los contras del uso de d-punteros?

Question

d-punteros son muy utilizados en Qt, son una implementación de idioma pimpl. Conozco las ventajas y desventajas del idioma pimpl. Pero me he perdido las ventajas de la implementación de d-punteros. Here y here son las muestras de d-punteros. ¿No es más fácil simplemente usar esto?

class MyClassPrivate; 
class MyClass { 
    // interface methods 
private: 
    MyClassPrivate *pimpl_; 
}; 

Answer 1

El conjunto de macros para el patrón de puntero d proporciona cierta conveniencia y consistencia. Por ejemplo, Q_DECLARE_PRIVATE asegura que la clase privada pimpl para Foo recibe el nombre de FooPrivate, que FooPrivate se hace amigo de Foo y crea una bonita función en línea (versiones const y nonconst) llamada d_func(). Este último se usa en la macro Q_D, que básicamente crea una variable local/con ámbito d que apunta a la instancia de clase privada.

En resumen, no necesita usar Q_DECLARE_PRIVATE y otras macros, pero al hacerlo, el código será más corto, más limpio y consistente.

Answer 2

creo que la D-punteros son realmente sólo unos macros útiles para la aplicación de la pimpl idioma. Simplemente eche un vistazo a la definición de todas estas macros: Q_D, Q_Q, Q_DECLARE_PRIVATE, etc. Son solo atajos para partes de pimpl. Por ejemplo, la mayoría de las veces desea mantener la referencia a la clase original en la clase privada. Hay Q_Q y Q_DECLARE_PUBLIC para esto. Después de todo, usar las macros obliga a todo el equipo a tener una implementación uniforme de pimpl. De lo contrario, algunas personas llamarían al puntero privado d, otros pimpl_, imaginen este lío.

Answer 3

d-punteros son una implementación, entre muchas, del patrón pimpl. También es una de las primeras implementaciones: "El nombre 'd-pointer' proviene de Arnt Gulbrandsen de Trolltech, quien introdujo la técnica por primera vez en Qt, convirtiéndola en una de las primeras bibliotecas de GUI de C++ en mantener la compatibilidad binaria incluso entre versiones más grandes. "Source

Una de las ventajas del uso de macros es la opción de cambiar algunos detalles de implementación de la implementación del patrón en un lugar central en tiempo de compilación. Por ejemplo, podría diseñar sus macros para dejarle la opción de cambiar al fast pimpl implementation en un momento posterior sin cambiar toneladas de código (con suerte no necesitará esto si está utilizando pimpl :-)). Siempre que no haya cometido errores en su diseño/implementación macro ...

Sin embargo, personalmente recomendaría evitar las macros para su implementación de pimpl ya que son crípticas para cualquier recién llegado al árbol fuente. Las macros crean dialectos mágicos que a menudo son propensos a errores y no tan significativos como el código fuente original. También vienen con todos los problemas asociados con el preprocesador C; no tiene conocimiento del lenguaje subyacente.

Personalmente me gusta usar lo que llamo una d-referencia. En lugar de un puntero, usa una referencia y no tiene que hacer una referencia d. 8-) Parece algo como esto:

// MyClass.h 

class MyClass 
{ 
public: 
    MyClass(); 
    ~MyClass(); 

    // implementation methods 

private: 
    class MyClassPrivate& d; 
}; 

// MyClass.cpp 

struct MyClassPrivate 
{ 
    int x; 
}; 

MyClass::MyClass() 
: d(*new MyClassPrivate) 
{ 

} 

MyClass::~MyClass() 
{ 
    delete &d; 
} 

// In methods use d.x