c++ - Asignador personalizado(pool) con boost shared_ptr

shared-ptr allocator

Question

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

Answer 1

Aquí está el código para hacer lo que quiera (probablemente no se compilará porque no tengo el impulso a mano y lo estoy escribiendo desde la 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();

Implementé esto dos veces, en dos proyectos diferentes. En ambos, las funciones de crear y destruir estaban sincronizadas (puede agregar un bloqueo de boost::mutex bloqueo de boost::mutex alrededor del uso del asignador) y eran miembros de una clase de fábrica (y la firma del destroy se modificó para 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 vago para escribir todo eso ahora :).

Editar (moví mi comentario de respuesta aquí para el formato del código):

Para enlazar la función de destrucción:

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 shared_ptr (si se ClassFactory instancia de ClassFactory , este puntero pasado a la instancia de shared_ptr no será válido y bloqueará su aplicación cuando shared_ptr elimine la instancia de YourClass ).

Answer 2

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

Donde se trata es en la eliminación de la memoria que ya no se hace referencia. Si ha asignado algo diferente al montón predeterminado, deberá proporcionar un eliminador personalizado.

Answer 3

Solución evidente:

Crea tu propia función make_shared e impone el uso de este método a shared_ptr creado. Aquellos que se derivan de La Regla serán castigados.

Nota:

Parece haber una confusión con el rol de 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.