Francisco Dibar, el 17 de noviembre a las 19:47 me escribiste:
> hola gente, les hago una pregunta:
> 
> como harian lo siguiente?:
> 
> Quieren invocar una funcion f, y atrapar distintas excepciones. Al
> atrapar una en particular, deciden reintentar f.
> Esto suena muy sencillo, pero si escribo la invocacion a f en el scope
> del catch para esa excepcion en particular, tengo que reescribir todos
> los catch de las demas excepciones. La unica forma que encontre de
> resolver esto es con un goto!
> Estoy seguro que debe haber una forma mas elegante de resolver esto,
> pero no se me ocurre.

Yo no le veo nada de malo. Si el goto te parece poco elegante, podés usar
un goto encubierto, algo así como:

while (true)
{
        try {
                f(i);
        }
        catch(const e1& e) {
                cout << e.what() << endl;
                static bool catchedOnce = false;
                i = 2;
                if (!catchedOnce) {
                        catchedOnce = true;
                }
        }
        catch(const e2& e) {
                cout << e.what() << endl;
        }
        break;
}

O algo así como con "flags":

bool retry = true;
while (retry)
{
        try {
                f(i);
        }
        catch(const e1& e) {
                cout << e.what() << endl;
                static bool catchedOnce = false;
                i = 2;
                if (!catchedOnce) {
                        catchedOnce = true;
                }
        }
        catch(const e2& e) {
                cout << e.what() << endl;
        }
        retry = false;
}

Pero en este caso en particular, yo creo que queda más claro el goto.

Otra forma sería "refactorizar":

bool ff (int i)
{
        try {
                f(i);
        }
        catch(const e1& e) {
                cout << e.what() << endl;
                return false;
        }
        catch(const e2& e) {
                cout << e.what() << endl;
        }
        return true;
}

Y luego algo como:

if (ff(i)) return;
ff(2);
return;

(si no entendí mal, tu código reintenta una sola vez)

Pero nuevamente, me parece más claro el goto en este caso.


PD: Probablemente quieras heredar tus excepciones de algo más concreto que
    std::exception, algo como std::runtime_exception o alguna otra de
    <stdexcept>.

-- 
Leandro Lucarella (luca) | Blog colectivo: http://www.mazziblog.com.ar/blog/
 .------------------------------------------------------------------------,
  \  GPG: 5F5A8D05 // F8CD F9A7 BF00 5431 4145  104C 949E BFB6 5F5A 8D05 /
   '--------------------------------------------------------------------'
Una mujer en bicicleta, con sombrero de paja, es la más flagrante
violación a las leyes de la aerodinamia.
        -- Ricardo Vaporeso. 21 de Septiembre de 1917.
_______________________________________________
Lista de correo Programacion.
[email protected]
http://listas.fi.uba.ar/mailman/listinfo/programacion

Responder a