¿Separar un puntero de un RPP compartido? [duplicar]

Siempre hay una manera: -)

Hay una razón por la que no proporcionan un método release (), pero no es imposible crear uno. Haz tu propio deleter. Algo en la línea de (en realidad no han compilado el código, pero esta es la noción general):

template <typename T>
class release_deleter{
public:
  release_deleter() : released_(new some_atomic_bool(false)){}
  void release() {released_->set(true);}
  void operator()(T* ptr){if(!released_->get()) delete ptr;}
private:
  shared_ptr<some_atomic_bool> released_;
}

..

shared_ptr<some_type> ptr(new some_type, release_deleter<some_type>());

..

release_deleter<some_type>* deleter = get_deleter<release_deleter<some_type>>(ptr);
deleter->release();
some_type* released_ptr = ptr.get();

Se supone que el usuario debe tomar posesión de ese objeto. No quiero devolver un impulso.shared_ptr,

shared_ptr expresa propiedad compartida, y desea que su interfaz exprese transferencia de propiedad. std::auto_ptr sería así más aplicable aquí.

Internamente sin embargo, me gustaría almacenar el puntero en un shared_ptr para evitar fugas de memoria en caso de excepciones

De nuevo, shared_ptr puede no ser la mejor herramienta para ese trabajo. Para evitar fugas en el caso de excepciones, scoped_ptr o auto_ptr sería más adecuado.

Use un shared_ptr a un scoped_ptr al recurso (shared_ptr<scoped_ptr<Resource>>). De esta manera se obtiene el conteo de referencias de shared_ptr, que destruirá automáticamente el recurso si y solo si todavía está unido a scoped_ptr. Pero puede separar el scoped_ptr cuando esté listo para entregar la propiedad.

Como James ha cubierto bien, realmente no se puede separar un puntero compartido.

¿Necesita varios propietarios internamente, o está transfiriendo la propiedad de su clase al cliente? En ese caso, un std::auto_ptr podría encajar en la factura.

Si le preocupa la sorprendente semántica de std::auto_ptr, podría sostenerlo internamente por boost::scoped_ptr y separarlo en el punto en que lo entregue, dejando que el cliente lo elimine manualmente o lo almacene en su propio puntero inteligente.

Si lo haces tenga varios propietarios de su lado, podría usar un conteo intrusivo. Internamente podría usar boost::intrusive__ptr, pero entregar el puntero raw en la interfaz. El cliente puede entonces trabajar manualmente con recuentos de ref, o almacenarlo en un boost::intrusive_ptr ellos mismos (pero usted no hace que dependan de él)