Cuando un objeto RAII falla al construir

Question

Supongamos que construyo un objeto RAII, y ese objeto puede fallar al construirlo. ¿Cómo manejo esto?

try { 
    std::vector<int> v(LOTS); 
    // try scope ends here because that's what the catch is for 
} catch(const std::bad_alloc&) { 
    // ... 
} 
// v? what v? 

Por supuesto, el constructor por defecto de std::vector no va a tirar y que puede ayudar, pero esto no es el caso general. Un constructor puede arrojar muy bien. Si deseo manejar cualquier falla en la adquisición de recursos, ¿cómo puedo hacer eso mientras sigo siendo capaz de proceder si no tiene tiro?

Editar: Para aclarar, mi problema es que si un recurso no puede adquirir, es posible que desee intentarlo de nuevo, y así sucesivamente. Tal vez pueda intentar adquirir un recurso alternativo.

Answer 1

Depende de lo que quieres decir con "proceed". Cualquier operación que requiera el recurso fallará: eso es lo que "requiere" significa. Así que cuando usted quiere continuar después de un error, que podría terminar de escribir código como este:

void something_using_RAII(thingummy &t) { 
    vector<int> v(t.size_required); 
    // do something using v 
} 

... 

for each thingummy { 
    try { 
     something_using_RAII(this_thingummy); 
    } catch(const std::bad_alloc &) { 
     std::cerr << "can't manage that one, sorry\n"; 
    } 
} 

Es por eso que sólo debe capturar las excepciones cuando hay algo que vale la pena que puede hacer con ellos (en este caso, la insuficiencia informe y pasar a la siguiente cosita).

Si desea intentarlo de nuevo en caso de fallo, pero sólo si falla el constructor, no se si todo lo demás falla:

while(not bored of trying) { 
    bool constructor_failed = true; 
    try { 
     vector<int> v(LOTS); 
     constructor_failed = false; 
     // use v 
    } catch(...) { 
     if (!constructor_failed) throw; 
    } 
} 

Esto es más o menos cómo std::new_handler obras - el controlador se denomina en el captar cláusula de un bucle similar, aunque sin necesidad de una bandera.

Si quieres probar un recurso diferente en caso de fallo:

try { 
    vector<int> v(LOTS); 
    // use v 
} catch(...) try { 
    otherthing<int> w(LOTS); 
    // use w 
} catch(...) { 
    // failed 
} 

Si "el uso v" y "uso w" son básicamente el mismo código, a continuación, refactorizarán en una función y lo llaman de ambos lugares. Tu función está haciendo bastante en este punto.

Answer 2

Si se lanza un constructor RAII, todos los recursos vinculados a los objetos RAII antes del punto de lanzamiento se limpiarán correctamente. Las reglas de C++ están razonablemente diseñadas para garantizar eso.

Si su construcción v lanza a causa de una bad_alloc entonces cualquier objeto RAII creado antes de la v en el bloque try se limpia correctamente.

Por lo tanto, si en consecuencia usa RAII, no necesita un manual try/catch así porque los objetos RAII manejan la limpieza por usted. Si lo necesita lo necesita por alguna razón, en el caso anterior puede usar swap como el siguiente.

std::vector<int> v; 
try { 
    std::vector<int> vtry(LOTS); 
    v.swap(vtry); // no-throw 
} catch(const std::bad_alloc&) { 
    // ... 
} 
// v! 

Answer 3

Si no se puede crear v, no se puede ejecutar todo el código que intenta usar v. Mueva el catch después del código que usa el código v, en un lugar donde es razonable continuar la ejecución si no hay v.

Answer 4

Todo código que use v debe estar en el bloque try.Si la pregunta es cómo entonces a reducir el código que lanzó la excepción, puede utilizar algún tipo de bandera para indicar en qué parte del bloque try usted es, de esta manera:

string flag; 
try 
{ 
    flag = "creating vector<int> v"; 
    std::vector<int> v(LOTS); 

    flag = "performing blaggity bloop"; 
    blaggity_bloop(); 

    flag = "doing some other stuff"; 
    some_other_stuff(); 
} 
catch(const std::bad_alloc&) 
{ 
    cerr << "Bad allocation while " << flag << endl; 
}