n-op para el impulso :: shared_ptr

Question

¿Hay un deallocator RS-op en Boost para usar con boost::shared_ptr de objetos estáticos, etc.

Sé que es ultra-trivial para escribir, pero no lo hago quiero rociar mi código con funciones muy pequeñas si ya hay una disponible.

Answer 1

sí hay uno aquí:

#include <boost/serialization/shared_ptr.hpp> // for null_deleter 

class Foo 
{ 
    int x; 
}; 

Foo foo; 
boost::shared_ptr<Foo> sharedfoo(&foo, boost::serialization::null_deleter()); 

Hay, por supuesto, un peligro con el hecho de que lo que necesita saber la función que llama no almacenar el shared_ptr para su uso posterior, ya que en realidad va en contra de la política de shared_ptr en que el objeto subyacente sigue siendo válido hasta el de la última instancia de shared_ptr.

Answer 2

¿No sería más limpio simplemente tomar una referencia adicional para que nunca se llame al deslocalizador? (Aunque todavía no es muy limpio.)

No puedo decir que no haya ninguna función en Boost que haga el trabajo, pero no parece que sea algo que quisieran incluir.

EDIT: Después de leer los comentarios y un poco de documentación, que se reduce a esto: la fuga

1. de referencia. En algún punto, ejecute esto:

   new shared_ptr(my_global_shared_ptr); 
   

   Ventajas: conceptualmente fácil. Desventajas: estás filtrando algo en el montón.

2. Desbloqueo personalizado. Como shared_ptr requiere poco de la función de desasignación, una función de identidad anónima como la proporcionada en la otra respuesta funcionaría bien.

   Ventajas: aprovecha Boost y no tiene absolutamente ningún gasto. Disconvantages: requiere un poco de documentación.

3. Objeto global no estático. Si hay un shared_ptr global para su objeto, ese debería ser el único medio de acceso al mismo. Reemplace la declaración de global por shared_ptr intializada por new my_class. Creo que esto es lo mejor

Answer 3

solución utiliza Boost.Lambda:

#include <boost/shared_ptr.hpp> 
#include <boost/lambda/lambda.hpp> 

int main() 
{ 
    int *p = new int(5); 

    { 
     boost::shared_ptr<int> sp(p, boost::lambda::_1); 
    } 

    delete p; 
} 

'boost :: lambda :: _ 1' crea un vacío funtor que toma un argumento.

Es probable que desee poner un // comentario allí para que las personas sepan por qué lo hizo.

Answer 4

Hay un boleto para esto en el rastreador de errores Boost: https://svn.boost.org/trac/boost/ticket/1913 - sin actividad durante mucho tiempo hasta que un murmullo hace dos semanas.

Answer 5

FWIW, esto es lo que estoy usando. Lo uso en pruebas unitarias para adaptar un local en un shared_ptr.

// The class NoOp_sptr_Deleter can be used to construct a shared_ptr<>() 
// that will NOT delete the pointee. 
// This can be helpful in unit-testing. Wrapping a local as a shared_ptr. 
// Do take care with the lifetimes though. 
struct NoOp_sptr_Deleter 
{ 
    void operator()(void const *) const {} 
}; 

template<typename T> 
boost::shared_ptr<T> FakeSharedPtrFromRef(T& aRef) 
{ 
    return boost::shared_ptr<T>(&aRef, NoOp_sptr_Deleter()); 
} 

Answer 6

• Si Boost <= 1.54, use boost/log/utility/empty_deleter.hpp.
• Si Boost == 1.55, usa boost/utility/empty_deleter.hpp.
• Si Boost >= 1.56, usa boost/core/null_deleter.hpp.