¿Cómo es posible (si lo es) implementar shared_ptr sin requerir que las clases polimórficas tengan un destructor virtual?

El Sr. Lidström y yo tuvimos una discusión 🙂

La afirmación del Sr. Lidström es que una construcción shared_ptr<Base> p(new Derived); no requiere que Base tenga un destructor virtual:

Armen Tsirunyan: “¿En serio? ¿El ptr_compartido limpiar correctamente? ¿Podría, en este caso, demostrar cómo se podría implementar ese efecto?”

Daniel Lidström: “Él ptr_compartido utiliza su propio destructor para eliminar la instancia de Concrete. Esto se conoce como RAII dentro de la comunidad de C++. Mi consejo es que aprendas todo lo que puedas sobre RAII. Hará que su codificación C++ sea mucho más fácil cuando use RAII en todas las situaciones”.

Armen Tsirunyan: “Sé sobre RAII, y también sé que eventualmente el ptr_compartido destructor puede eliminar el px almacenado cuando pn llega a 0. Pero si px tuviera un puntero de tipo estático a Base y puntero de tipo dinámico a Derivedentonces a menos que Base tiene un destructor virtual, esto dará como resultado un comportamiento indefinido. Corrígeme si estoy equivocado.”

Daniel Lidström: “Él ptr_compartido sabe que el tipo estático es Concreto. ¡Lo sabe desde que lo pasé en su constructor! Parece un poco mágico, pero les puedo asegurar que es por diseño y extremadamente agradable”.

Entonces, júzguenos. ¿Cómo es posible (si lo es) implementar ptr_compartido sin requerir clases polimórficas para tener destructor virtual?

Sí, es posible implementar shared_ptr de esa manera. Boost lo hace y el estándar C++ 11 también requiere este comportamiento. Como una flexibilidad adicional, shared_ptr administra más que solo un contador de referencia. El llamado borrador generalmente se coloca en el mismo bloque de memoria que también contiene los contadores de referencia. Pero la parte divertida es que el tipo de este borrador no es parte del tipo shared_ptr. Esto se llama “borrado de tipos” y es básicamente la misma técnica utilizada para implementar las “funciones polimórficas”. boost::function o std::function para ocultar el tipo de funtor real. Para que su ejemplo funcione, necesitamos un constructor con plantilla:

template<class T>
class shared_ptr
{
public:
   ...
   template<class Y>
   explicit shared_ptr(Y* p);
   ...
};

Entonces, si usas esto con tus clases Base y Derived …

class Base {};
class Derived : public Base {};

int main() {
   shared_ptr<Base> sp (new Derived);
}

… el constructor con plantilla con Y=Derived se utiliza para construir el shared_ptr objeto. El constructor tiene así la oportunidad de crear el objeto eliminador apropiado y los contadores de referencia y almacena un puntero a este bloque de control como un miembro de datos. Si el contador de referencia llega a cero, el previamente creado y DerivedSe utilizará un eliminador consciente para deshacerse del objeto.

El estándar C++11 dice lo siguiente sobre este constructor (20.7.2.2.1):

Requiere: p debe ser convertible a T*. Y será un tipo completo. La expresion delete p estará bien formado, tendrá un comportamiento bien definido y no arrojará excepciones.

Efectos: Construye un shared_ptr objeto ese posee el puntero p.

…

Y para el destructor (20.7.2.2.2):

Efectos: Si *this es vacío o comparte la propiedad con otro shared_ptr instancia (use_count() > 1), No hay efectos secundarios. De lo contrario, si *this posee un objeto p y un eliminador d, d(p) se llama.
De lo contrario, si *this posee un puntero py delete p se llama.

(el énfasis en negrita es mío).

Cuando se crea shared_ptr, almacena un borrador objeto dentro de sí mismo. Se llama a este objeto cuando shared_ptr está a punto de liberar el recurso apuntado. Como sabe cómo destruir el recurso en el punto de construcción, puede usar shared_ptr con tipos incompletos. Quienquiera que haya creado shared_ptr almacenó un eliminador correcto allí.

Por ejemplo, puede crear un eliminador personalizado:

void DeleteDerived(Derived* d) { delete d; } // EDIT: no conversion needed.

shared_ptr<Base> p(new Derived, DeleteDerived);

p llamará a DeleteDerived para destruir el objeto puntiagudo. La implementación hace esto automáticamente.

Simplemente,

shared_ptr usa una función de eliminación especial creada por un constructor que siempre usa el destructor del objeto dado y no el destructor de Base, esto es un poco de trabajo con la metaprogramación de plantilla, pero funciona.

Algo como eso

template<typename SomeType>
shared_ptr(SomeType *p)
{
   this->destroyer = destroyer_function<SomeType>(p);
   ...
}