¿Es excesivo usar scoped_ptr en casos simples?

Question

Estoy usando scoped_ptr dentro de pequeñas funciones como esta. para que no tenga que llamar borrar ¿Es esto una exageración para este uso? Los miembros de mi equipo prefieren punteros sin procesar y eliminar. ¿Cuál es el costo de usar scoped_ptr si se utiliza en una ruta muy crítica? ¿No debería estar alineado y ser exactamente equivalente a simplemente usar la eliminación normal en binario optimizado?

void myfunc() 
{ 
    boost::scoped_ptr<myobj> objptr = someFactory::allocate(); 
    callsomeotherfunc(objptr.get()); 
} 

Answer 1

estoy seguro del impacto en el rendimiento, pero utilizando scoped_ptr aquí asegura myfunc() es segura excepción: si se produce una excepción callsomeotherfunc() todavía se liberó a la memoria asignada dinámicamente. Si scoped_ptr no se utilizó y callsomeotherfunc() podría lanzar entonces la función tendría que ser estructurado similar a esto:

void myfunc() 
{ 
    myobj* objptr = someFactory::allocate(); 

    try 
    { 
     callsomeotherfunc(objptr); 
     delete objptr; 
    } 
    catch (const some_exception&) 
    { 
     delete objptr; 
     throw; 
    } 
} 

Ésta es propenso a errores, como todos los futuros modificaciones de la función necesitarían para asegurar que delete objptr; se invoca en todas las posibles puntos de salida

Answer 2

No, no lo es. El beneficio de usar puntero inteligente (por ejemplo, seguridad de excepción y limpieza automática de recursos) es mucho mayor que la pérdida de rendimiento de usar un par de bytes adicionales de memoria y un par de relojes de CPU adicionales necesarios para la creación, mantenimiento y destrucción de punteros inteligentes.

Answer 3

yo no usaría scoped_ptr para tal fin, sino más bien unique_ptr en C++ 11 y auto_ptr en los compiladores de más edad, ambos de los cuales son equivalentes para el caso de uso particular. A partir de si es excesivo, no, no lo es, es la única opción para proporcionar seguridad de excepción (digamos cualquier cosa en el código de myfunc o callsomeotherfunc throws, desea que se libere la memoria). En cuanto a rendimiento, las tres opciones son equivalentes a tener una llamada delete al final de la función en el caso donde no se lanzan excepciones, y más rápido que tener un bloque try/catch con un delete que vuelve a lanzar la excepción en caso de excepciones.

Además, parece que está asignando desde una fábrica, en algunos diseños que la fábrica tendrá una operación deallocate que necesita ser llamada, en lugar de delete. Si ese es el caso, puede considerar un puntero inteligente diferente (shared_ptr del estándar, que sería exagerado si delete es la forma correcta de liberar la memoria, o un poco menos de managed_ptr para el que también puede proporcionar un eliminador)

Answer 4

creo que el equivalente a scoped_ptr uso sería:

void myfunc() 
{ 
    myobj* objptr = someFactory::allocate(); 
    try 
    { 
     callsomeotherfunc(objptr); 
    } 
    catch (...) 
    { 
     delete objptr; 
     throw; 
    } 
    delete objptr; 
} 

yo sé qué versión preferiría escribir ...