Asignador personalizado (pool) con impulso shared_ptr

Question

Quiero que los objetos administrados por un shared_ptr se asignen desde un grupo, por ejemplo, la interfaz Pool de Boost, ¿cómo se puede lograr esto?

Answer 1

Aquí está el código para hacer lo que quiere (probablemente no se compilará como no tengo impulso en la mano y lo estoy escribiendo de memoria):

class YourClass; // your data type, defined somewhere else 

boost::object_pool<YourClass> allocator; 

void destroy(YourClass* pointer) 
{ 
    allocator.destroy(pointer); 
} 

boost::shared_ptr<YourClass> create() 
{ 
    // usage of object_pool<??>::construct requires that you have a 
    // YourClass::YourClass(void) defined. If you need to pass arguments 
    // to the new instance, you need to do that separately. 
    // 
    // for example using a YourClass::Initialize(your,parameters,here) method 
    // before returning from this function 
    return boost::shared_ptr<YourClass>(allocator.construct(), &destroy); 
} 

// usage: 
boost::shared_ptr<YourClass> newObject = create(); 

He implementado esto dos veces, en dos proyectos diferentes En ambas, las funciones crear y destruir estaban sincronizadas (puede agregar un bloqueo boost::mutex en el uso del asignador) y eran miembros de una clase de fábrica (y la firma destroy se modificó a void (YourClass*) mediante el uso de boost::bind).

También puede evitar escribir dos funciones adicionales (destroy y create) vinculando object_pool<YourClass>::destroy dirrectly en el constructor boost :: shared_ptr.

Soy demasiado perezoso para escribir todo eso ahora :).

Editar (se ha llevado mi comentario respuesta en aquí para el formato de código):

Para obligar a la función de destruir:

class ClassFactory 
{ 
    boost::object_pool<YourClass> allocator; 
public: 
    boost::shared_ptr<YourClass> create() 
    { 
     return boost::shared_ptr<YourClass>(
      allocator.construct(), 
      boost::bind(&ClassFactory::destroy, this, _1)); 
    } 

    void destroy(YourClass* pointer) 
    { 
     allocator.destroy(pointer); 
    } 
}; 

ClassFactory debe tener una vida útil más larga que la shared_ptr (si el ClassFactory la instancia se elimina, el puntero pasado a la instancia shared_ptr no será válido y bloqueará la aplicación cuando shared_ptr elimine la instancia YourClass).

Answer 2

Estas son preocupaciones casi ortogonales. shared_ptr no juega ningún papel en la asignación de objetos.

Cuando es de que se trate está en la eliminación de memoria ya no se hace referencia. Si ha asignado desde que no sea el montón predeterminado todo lo que necesita para provide a custom deleter

Answer 3

solución evidente:

Cree su propia función make_shared y hacer cumplir el uso de este método para shared_ptr creado. Aquellos que se derivan de La Regla serán castigados.

Nota:

No parece haber una confusión con el papel de la shared_ptr. Su función es gestionar la memoria de lo que TÚ ha asignado, sin embargo para hacerlo requiere una asignación propia (contador y eliminador), por lo tanto, puedes pasarle un asignador para eso.