¿Por qué no hay una construcción 'finalmente' en C ++?

El manejo de excepciones en C ++ se limita a try / throw / catch. A diferencia de Object Pascal, Java, C # y Python, incluso en C ++ 11, la finallyconstrucción no se ha implementado.

He visto una gran cantidad de literatura de C ++ sobre "código seguro de excepción". Lippman escribe que el código seguro de excepción es un tema importante pero avanzado y difícil, más allá del alcance de su Manual, lo que parece implicar que el código seguro no es fundamental para C ++. ¡Herb Sutter dedica 10 capítulos al tema en su Excepcional C ++!

Sin embargo, me parece que muchos de los problemas encontrados al intentar escribir "código seguro de excepción" podrían resolverse bastante bien si finallyse implementara la construcción, lo que le permite al programador asegurarse de que incluso en caso de una excepción, el programa pueda restaurarse a un estado seguro, estable y sin fugas, cerca del punto de asignación de recursos y código potencialmente problemático. Como programador muy experimentado de Delphi y C #, uso try .. finalmente bloquea bastante en mi código, al igual que la mayoría de los programadores en estos lenguajes.

Teniendo en cuenta todas las 'campanas y silbatos' implementados en C ++ 11, me sorprendió descubrir que 'finalmente' todavía no estaba allí.

Entonces, ¿por qué la finallyconstrucción nunca se ha implementado en C ++? Realmente no es un concepto muy difícil o avanzado de comprender y ayuda mucho al programador a escribir 'código seguro de excepción'.

Como comentario adicional sobre la respuesta de @ Nemanja (que, dado que cita a Stroustrup, es realmente una respuesta tan buena como puedes obtener):

Realmente es solo una cuestión de entender la filosofía y los modismos de C ++. Tome su ejemplo de una operación que abre una conexión de base de datos en una clase persistente y tiene que asegurarse de que cierra esa conexión si se produce una excepción. Esta es una cuestión de seguridad excepcional y se aplica a cualquier lenguaje con excepciones (C ++, C #, Delphi ...).

En un lenguaje que usa try/ finally, el código podría verse así:

database.Open();
try {
    database.DoRiskyOperation();
} finally {
    database.Close();
}

Simple y directo. Sin embargo, hay algunas desventajas:

• Si el lenguaje no tiene destructores deterministas, siempre tengo que escribir el finallybloque, de lo contrario pierdo recursos.
• Si se DoRiskyOperationtrata de más de una llamada a un método, si tengo que procesar algo en el trybloque, entonces la Closeoperación puede terminar estando un poco lejos de la Openoperación. No puedo escribir mi limpieza justo al lado de mi adquisición.
• Si tengo varios recursos que necesitan ser adquiridos y luego liberados de manera segura, puedo terminar con varias capas de profundidad try/ finallybloques.

El enfoque de C ++ se vería así:

ScopedDatabaseConnection scoped_connection(database);
database.DoRiskyOperation();

Esto resuelve completamente todas las desventajas del finallyenfoque. Tiene algunas desventajas propias, pero son relativamente menores:

• Hay una buena posibilidad de que necesites escribir la ScopedDatabaseConnectionclase tú mismo. Sin embargo, es una implementación muy simple: solo 4 o 5 líneas de código.
• Implica crear una variable local adicional, de la que aparentemente no eres fanático, basado en tu comentario sobre "crear y destruir constantemente clases para confiar en sus destructores para limpiar tu desorden es muy pobre", pero un buen compilador optimizará eliminar el trabajo adicional que implica una variable local adicional. El buen diseño de C ++ se basa mucho en este tipo de optimizaciones.

Personalmente, considerando estas ventajas y desventajas, considero que RAII es una técnica mucho más preferible finally. Su experiencia puede ser diferente.

Finalmente, debido a que RAII es un idioma muy bien establecido en C ++, y para aliviar a los desarrolladores de la carga de escribir numerosas Scoped...clases, hay bibliotecas como ScopeGuard y Boost.ScopeExit que facilitan este tipo de limpieza determinista.

¿ Por qué C ++ no proporciona una construcción "finalmente"? en Preguntas frecuentes sobre el estilo y la técnica C ++ de Bjarne Stroustrup :

Debido a que C ++ admite una alternativa que casi siempre es mejor: la técnica de "adquisición de recursos es inicialización" (TC ++ PL3 sección 14.4). La idea básica es representar un recurso por un objeto local, de modo que el destructor del objeto local libere el recurso. De esa manera, el programador no puede olvidar liberar el recurso.

La razón por la que C ++ no tiene finallyes porque no se necesita en C ++. finallyse usa para ejecutar algún código independientemente de si se produjo una excepción o no, lo que casi siempre es algún tipo de código de limpieza. En C ++, este código de limpieza debe estar en el destructor de la clase relevante y siempre se llamará al destructor, como un finallybloque. El idioma de usar el destructor para su limpieza se llama RAII .

Dentro de la comunidad C ++ puede que se hable más sobre el código de "excepción segura", pero es casi igualmente importante en otros lenguajes que tienen excepciones. El punto principal del código de 'excepción segura' es que usted piensa en qué estado queda su código si ocurre una excepción en cualquiera de las funciones / métodos que llama.
En C ++, el código de 'excepción segura' es un poco más importante, porque C ++ no tiene recolección automática de basura que se encarga de los objetos que quedan huérfanos debido a una excepción.

La razón por la cual la seguridad de excepción se discute más en la comunidad de C ++ probablemente también se debe al hecho de que en C ++ debe ser más consciente de lo que puede salir mal, porque hay menos redes de seguridad predeterminadas en el lenguaje.

Otros han discutido RAII como la solución. Es una solución perfectamente buena. Pero eso realmente no aborda por qué no agregaron finallytambién, ya que es algo muy deseado. La respuesta a eso es más fundamental para el diseño y desarrollo de C ++: durante el desarrollo de C ++, los involucrados se han resistido fuertemente a la introducción de características de diseño que se pueden lograr utilizando otras características sin una gran cantidad de complicaciones y especialmente cuando esto requiere la introducción de nuevas palabras clave que podrían hacer que el código anterior sea incompatible. Dado que RAII proporciona una alternativa altamente funcional finallyy finally, de todos modos, puede implementar la suya propia en C ++ 11, hubo poca necesidad de hacerlo.

Todo lo que necesita hacer es crear una clase Finallyque llame a la función pasada a su constructor en su destructor. Entonces puedes hacer esto:

try
{
    Finally atEnd([&] () { database.close(); });

    database.doRisky();
}

Sin embargo, la mayoría de los programadores nativos de C ++ preferirán, en general, objetos RAII de diseño limpio.

Puede usar un patrón de "trampa", incluso si no desea usar el bloque try / catch.

Poner un objeto simple en el alcance requerido. En el destructor de este objeto pon tu lógica "final". No importa qué, cuando la pila se desenrolla, se llamará al destructor del objeto y obtendrás tus dulces.

Bueno, podría hacer una especie de roll-own finally, usando Lambdas, que obtendría lo siguiente para compilar bien (usando un ejemplo sin RAII, por supuesto, no es el mejor código):

{
    FILE *file = fopen("test","w");

    finally close_the_file([&]{
        cout << "We're closing the file in a pseudo-finally clause." << endl;
        fclose(file);
    });
}

Ver este artículo .

No estoy seguro de estar de acuerdo con las afirmaciones aquí de que RAII es un superconjunto finally. El talón de Aquiles de RAII es simple: excepciones. RAII se implementa con destructores, y siempre está mal en C ++ tirar de un destructor. Eso significa que no puede usar RAII cuando necesita su código de limpieza para lanzar. Si finallyse implementaran, por otro lado, no hay razón para creer que no sería legal lanzar desde un finallybloque.

Considere una ruta de código como esta:

void foo() {
    try {
        ... stuff ...
        complex_cleanup();
    } catch (A& a) {
        handle_a(a);
        complex_cleanup();
        throw;
    } catch (B& b) {
        handle_b(b);
        complex_cleanup();
        throw;
    } catch (...) {
        handle_generic();
        complex_cleanup();
        throw;
    }
}

Si tuviéramos finally, podríamos escribir:

void foo() {
    try {
        ... stuff ...
    } catch (A& a) {
        handle_a(a);
        throw;
    } catch (B& b) {
        handle_b(b);
        throw;
    } catch (...) {
        handle_generic();
        throw;
    } finally {
        complex_cleanup();
    }
}

Pero no hay manera, que pueda encontrar, de obtener el comportamiento equivalente usando RAII.

Si alguien sabe cómo hacer esto en C ++, estoy muy interesado en la respuesta. Incluso estaría contento con algo que se basara, por ejemplo, en hacer cumplir todas las excepciones heredadas de una sola clase con algunas capacidades especiales o algo así.