Asignador personalizado (pool) con ptr compartido de boost

Aquí está el código para hacer lo que quieras (probablemente no compile ya que no tengo boost 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 create y destroy estaban sincronizadas (se puede agregar un bloqueo boost::mutex alrededor del uso de allocator) y eran miembros de una clase factory (y la firma de destroy se modificó a void (YourClass*) mediante el uso de boost::bind).

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

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