Por qué std:: shared ptr funciona

shared_ptr<T> lógicamente [*] tiene (al menos) dos miembros de datos relevantes:

• un puntero al objeto que se está gestionando
• un puntero a la función deleter que se utilizará para destruirla.

La función deleter de su shared_ptr<Test>, dada la forma en que la construyó, es la normal para Test, que convierte el puntero a Test* y delete lo hace.

Cuando empujas tu shared_ptr<Test> en el vector de shared_ptr<void>, ambos de ellos se copian, aunque el primero se convierte a void*.

Entonces, cuando el elemento vectorial es destruido tomando la última referencia con él, pasa el puntero a un deleter que lo destruye correctamente.

En realidad es un poco más complicado que esto, porque shared_ptr puede tomar un deleter funtor en lugar de solo una función, por lo que incluso podría haber datos por objeto para ser almacenados en lugar de solo un puntero de función. Pero para este caso no hay tales datos adicionales, sería suficiente solo para almacenar un puntero a una instanciación de una función de plantilla, con un parámetro de plantilla que captura el tipo a través del cual se debe eliminar el puntero.

[*] lógicamente en el sentido de que tiene acceso a ellos - pueden no ser miembros del mismo shared_ptr, sino en lugar de algún nodo de administración al que apunta.

Funciona porque utiliza el tipo erasure.

Básicamente, cuando construyes un shared_ptr, pasa un argumento adicional (que puedes proporcionar si lo deseas), que es el funtor deleter.

Este funtor por defecto acepta como argumento un puntero para escribir en el shared_ptr, por lo tanto void aquí, lo lanza apropiadamente al tipo estático que usó test aquí, y llama al destructor en este objeto.

Cualquier ciencia suficientemente avanzada se siente como magia, ¿no es así ?

El constructor shared_ptr<T>(Y *p) de hecho parece estar llamando a shared_ptr<T>(Y *p, D d) donde d es un deleter generado automáticamente para el objeto.

Cuando esto sucede, se conoce el tipo del objeto Y, por lo que el deleter para este objeto shared_ptr sabe a qué destructor llamar y esta información no se pierde cuando el puntero se almacena en un vector de shared_ptr<void>.

De hecho, las especificaciones requieren que para que un objeto receving shared_ptr<T> acepte un objeto shared_ptr<U> debe ser cierto y U* debe ser implícitamente convertible a T* y este es ciertamente el caso con T=void porque cualquier puntero puede convertirse a void* implícitamente. No se dice nada sobre el deleter que será inválido, por lo que las especificaciones exigen que esto funcione correctamente.

Técnicamente IIRC a shared_ptr<T> sostiene un puntero a un objeto oculto que contiene el contador de referencia y un puntero al objeto real; almacenando el deleter en esta estructura oculta es posible hacer esta característica aparentemente mágica trabajando mientras se mantiene shared_ptr<T> tan grande como un puntero regular (sin embargo, desreferenciar el puntero requiere una doble indirección

shared_ptr -> hidden_refcounted_object -> real_object

Voy a responder esta pregunta (2 años después) usando una implementación muy simplista de shared_ptr que el usuario entenderá.

En primer lugar voy a algunas clases laterales, shared_ptr_base, sp_counted_base sp_counted_impl, y checked_deleter la última de las cuales es una plantilla.

class sp_counted_base
{
 public:
    sp_counted_base() : refCount( 1 )
    {
    }

    virtual ~sp_deleter_base() {};
    virtual void destruct() = 0;

    void incref(); // increases reference count
    void decref(); // decreases refCount atomically and calls destruct if it hits zero

 private:
    long refCount; // in a real implementation use an atomic int
};

template< typename T > class sp_counted_impl : public sp_counted_base
{
 public:
   typedef function< void( T* ) > func_type;
    void destruct() 
    { 
       func(ptr); // or is it (*func)(ptr); ?
       delete this; // self-destructs after destroying its pointer
    }
   template< typename F >
   sp_counted_impl( T* t, F f ) :
       ptr( t ), func( f )

 private:

   T* ptr; 
   func_type func;
};

template< typename T > struct checked_deleter
{
  public:
    template< typename T > operator()( T* t )
    {
       size_t z = sizeof( T );
       delete t;
   }
};

class shared_ptr_base
{
private:
     sp_counted_base * counter;

protected:
     shared_ptr_base() : counter( 0 ) {}

     explicit shared_ptr_base( sp_counter_base * c ) : counter( c ) {}

     ~shared_ptr_base()
     {
        if( counter )
          counter->decref();
     }

     shared_ptr_base( shared_ptr_base const& other )
         : counter( other.counter )
     {
        if( counter )
            counter->addref();
     }

     shared_ptr_base& operator=( shared_ptr_base& const other )
     {
         shared_ptr_base temp( other );
         std::swap( counter, temp.counter );
     }

     // other methods such as reset
};

Ahora voy a crear dos funciones "libres" llamadas make_sp_counted_impl que devolverán un puntero a uno recién creado.

template< typename T, typename F >
sp_counted_impl<T> * make_sp_counted_impl( T* ptr, F func )
{
    try
    {
       return new sp_counted_impl( ptr, func );
    }
    catch( ... ) // in case the new above fails
    {
        func( ptr ); // we have to clean up the pointer now and rethrow
        throw;
    }
}

template< typename T > 
sp_counted_impl<T> * make_sp_counted_impl( T* ptr )
{
     return make_sp_counted_impl( ptr, checked_deleter<T>() );
}

Ok, estas dos funciones son esenciales en cuanto a lo que sucederá después cuando cree un shared_ptr a través de una función templada.

template< typename T >
class shared_ptr : public shared_ptr_base
{

 public:
   template < typename U >
   explicit shared_ptr( U * ptr ) :
         shared_ptr_base( make_sp_counted_impl( ptr ) )
   {
   }

  // implement the rest of shared_ptr, e.g. operator*, operator->
};

Tenga en cuenta lo que sucede arriba si T es nulo y U es su clase de "prueba". Llamará a make_sp_counted_impl () con un puntero a U, no un puntero a T. La gestión de la destrucción se realiza a través de aquí. La clase shared_ptr_base administra el conteo de referencias con respecto a la copia y asignación, etc. La clase shared_ptr gestiona el uso seguro de tipo de sobrecargas de operador ( - >, * sucesivamente).

Por lo tanto, aunque tenga un shared_ptr para anular, debajo está administrando un puntero del tipo que pasó a nuevo. Tenga en cuenta que si convierte su puntero a un void* antes de ponerlo en shared_ptr, fallará al compilar en checked_delete, por lo que también estará seguro allí.

Test* es implícitamente convertible a void*, por lo tanto shared_ptr<Test> es implícitamente convertible a shared_ptr<void>, de memoria. Esto funciona porque shared_ptr está diseñado para controlar la destrucción en tiempo de ejecución, no en tiempo de compilación, utilizarán internamente la herencia para llamar al destructor apropiado como lo estaba en el momento de la asignación.