Warum gibt es in C ++ kein 'finally'-Konstrukt?

Die Ausnahmebehandlung in C ++ ist auf try / throw / catch beschränkt. Im Gegensatz zu Object Pascal, Java, C # und Python wurde das finallyKonstrukt auch in C ++ 11 nicht implementiert.

Ich habe sehr viel C ++ - Literatur gesehen, die sich mit "Exception Safe Code" befasst. Lippman schreibt, dass sicherer Code für Ausnahmen ein wichtiges, aber fortgeschrittenes, schwieriges Thema ist, das über den Rahmen seines Primers hinausgeht - was zu bedeuten scheint, dass sicherer Code für C ++ nicht grundlegend ist. Herb Sutter widmet dem Thema in seinem Exceptional C ++!

Dennoch scheint es mir, dass viele der Probleme, die beim Versuch aufgetreten sind, "ausnahmesicheren Code" zu schreiben, ziemlich gut gelöst werden könnten, wenn das finallyKonstrukt implementiert würde, so dass der Programmierer sicherstellen kann, dass das Programm selbst im Falle einer Ausnahme wiederhergestellt werden kann in einen sicheren, stabilen und leckagefreien Zustand, in der Nähe der Ressourcenzuweisung und des potenziell problematischen Codes. Als sehr erfahrener Delphi- und C # -Programmierer verwende ich try .. finally-Blöcke ziemlich ausführlich in meinem Code, wie es die meisten Programmierer in diesen Sprachen tun.

Angesichts all der in C ++ 11 implementierten "Schnickschnack" war ich erstaunt, dass "endlich" immer noch nicht da war.

Warum wurde das finallyKonstrukt nie in C ++ implementiert? Es ist wirklich kein sehr schwieriges oder fortgeschrittenes Konzept und trägt wesentlich dazu bei, dem Programmierer das Schreiben von "ausnahmesicherem Code" zu erleichtern.

Als zusätzlichen Kommentar zu @ Nemanjas Antwort (die, da sie Stroustrup zitiert, wirklich so gut ist, wie Sie sie erhalten können):

Es geht wirklich nur darum, die Philosophie und Redewendungen von C ++ zu verstehen. Nehmen Sie ein Beispiel für eine Operation, die eine Datenbankverbindung für eine persistente Klasse öffnet und sicherstellen muss, dass diese Verbindung geschlossen wird, wenn eine Ausnahme ausgelöst wird. Dies ist eine Frage der Ausnahmesicherheit und gilt für alle Sprachen mit Ausnahmen (C ++, C #, Delphi ...).

In einer Sprache, die try/ verwendet finally, könnte der Code ungefähr so ​​aussehen:

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

Einfach und unkompliziert. Es gibt jedoch einige Nachteile:

• Wenn die Sprache keine deterministischen Destruktoren hat, muss ich immer den finallyBlock schreiben , sonst lecke ich Ressourcen.
• Wenn DoRiskyOperationes sich um mehr als einen einzelnen Methodenaufruf handelt - wenn ich im tryBlock etwas zu verarbeiten habe -, ist die CloseOperation möglicherweise ein gutes Stück von der OpenOperation entfernt. Ich kann meine Bereinigung nicht direkt neben meiner Anschaffung schreiben.
• Wenn ich mehrere Ressourcen habe, die auf eine ausnahmesichere Weise beschafft und dann freigegeben werden müssen, kann ich am Ende mehrere Ebenen mit einer Tiefe von try/ finallyBlöcken haben.

Der C ++ - Ansatz würde folgendermaßen aussehen:

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

Dies löst alle Nachteile des finallyAnsatzes vollständig . Es hat ein paar eigene Nachteile, aber sie sind relativ gering:

• Es besteht eine gute Chance, dass Sie die ScopedDatabaseConnectionKlasse selbst schreiben müssen . Es ist jedoch eine sehr einfache Implementierung - nur 4 oder 5 Codezeilen.
• Es geht darum, eine zusätzliche lokale Variable zu erstellen - von der Sie anscheinend nicht begeistert sind, basierend auf Ihrem Kommentar zu "Klassen ständig zu erstellen und zu zerstören, um sich auf ihre Destruktoren zu verlassen, um Ihr Chaos zu bereinigen, ist sehr schlecht" -, aber ein guter Compiler wird optimieren die zusätzliche Arbeit, die eine zusätzliche lokale Variable mit sich bringt. Gutes C ++ - Design hängt in hohem Maße von solchen Optimierungen ab.

In Anbetracht dieser Vor- und Nachteile empfinde ich RAII als eine viel bessere Technik als RAII finally. Ihr Kilometerstand kann variieren.

Schließlich Scoped...gibt es Bibliotheken wie ScopeGuard und Boost.ScopeExit , die diese Art der deterministischen Bereinigung ermöglichen , da RAII in C ++ eine so gut etablierte Redewendung ist und die Entwickler von der Last des Schreibens zahlreicher Klassen entlastet .

Von Warum C nicht ein „endlich“ konstruieren ++ zur Verfügung stellen? in Bjarne Stroustrups C ++ Style und Technik FAQ :

Weil C ++ eine Alternative unterstützt, die fast immer besser ist: Die Technik "Ressourcenbeschaffung ist Initialisierung" (TC ++ PL3, Abschnitt 14.4). Die Grundidee besteht darin, eine Ressource durch ein lokales Objekt darzustellen, sodass der Destruktor des lokalen Objekts die Ressource freigibt. Auf diese Weise kann der Programmierer nicht vergessen, die Ressource freizugeben.

Der Grund, den C ++ nicht hat, finallyist, dass es in C ++ nicht benötigt wird. finallywird verwendet, um Code auszuführen, unabhängig davon, ob eine Ausnahme aufgetreten ist oder nicht. Dies ist fast immer eine Art Bereinigungscode. In C ++ sollte sich dieser Bereinigungscode im Destruktor der betreffenden Klasse befinden, und der Destruktor wird immer wie ein finallyBlock aufgerufen . Die Redewendung, den Destruktor für die Bereinigung zu verwenden, heißt RAII .

In der C ++ - Community wird möglicherweise mehr über ausnahmesicheren Code gesprochen, in anderen Sprachen mit Ausnahmen ist dies jedoch fast genauso wichtig. Der springende Punkt bei "ausnahmesicherem" Code ist, dass Sie sich überlegen, in welchem ​​Zustand Ihr Code verbleibt, wenn bei einer der von Ihnen aufgerufenen Funktionen / Methoden eine Ausnahme auftritt.
In C ++ ist ausnahmesicherer Code etwas wichtiger, da in C ++ keine automatische Speicherbereinigung vorhanden ist, die Objekte berücksichtigt, die aufgrund einer Ausnahme verwaist sind.

Der Grund, warum die Ausnahmesicherheit in der C ++ - Community mehr diskutiert wird, beruht wahrscheinlich auch auf der Tatsache, dass Sie in C ++ besser wissen müssen, was schief gehen kann, da die Sprache weniger Standardsicherheitsnetze enthält.

Andere haben RAII als Lösung diskutiert. Es ist eine vollkommen gute Lösung. Aber das spricht nicht wirklich an, warum sie nicht finallyso gut hinzugefügt haben, da es eine weithin gewünschte Sache ist. Die Antwort darauf ist grundlegender für das Design und die Entwicklung von C ++: Während der gesamten Entwicklung von C ++ haben sich die Beteiligten nachdrücklich gegen die Einführung von Designmerkmalen gewehrt, die mit anderen Features ohne großen Aufwand erreicht werden können, und insbesondere dort, wo dies die Einführung erfordert von neuen Schlüsselwörtern, die älteren Code inkompatibel machen könnten. Da RAII eine hochfunktionale Alternative zu C ++ 11 bietet finallyund Sie Ihre eigenen finallysowieso in C ++ 11 rollen können, gab es wenig Nachfrage danach.

Sie müssen lediglich eine Klasse erstellen Finally, die die Funktion aufruft, die in ihrem Destruktor an ihren Konstruktor übergeben wird. Dann können Sie dies tun:

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

    database.doRisky();
}

Die meisten nativen C ++ - Programmierer bevorzugen jedoch im Allgemeinen sauber gestaltete RAII-Objekte.

Sie können ein "Trap" -Muster verwenden - auch wenn Sie den try / catch-Block nicht verwenden möchten.

Stellen Sie ein einfaches Objekt in den gewünschten Bereich. In den Destruktor dieses Objekts legen Sie Ihre "endgültige" Logik. Egal was passiert, wenn der Stapel abgewickelt wird, wird der Destruktor des Objekts aufgerufen und Sie erhalten Ihre Süßigkeiten.

Nun, Sie könnten finallymit Lambdas eine Art Roll-Your-Own- Methode verwenden, mit der sich Folgendes gut kompilieren lässt (anhand eines Beispiels ohne RAII, natürlich nicht das schönste Stück Code):

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

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

Siehe diesen Artikel .

Ich bin mir nicht sicher, ob ich der Behauptung zustimme, dass RAII eine Obermenge von ist finally. Die Achillesferse von RAII ist einfach: Ausnahmen. RAII wird mit Destruktoren implementiert, und es ist in C ++ immer falsch, einen Destruktor zu löschen. Das bedeutet, dass Sie RAII nicht verwenden können, wenn Sie Ihren Bereinigungscode zum Werfen benötigen. Wenn finallyes dagegen implementiert würde, gäbe es keinen Grund zu der Annahme, dass es nicht legal wäre, aus einem finallyBlock zu werfen .

Betrachten Sie einen Codepfad wie diesen:

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;
    }
}

Wenn wir hätten finally, könnten wir schreiben:

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();
    }
}

Aber ich kann keine Möglichkeit finden, mit RAII ein gleichwertiges Verhalten zu erzielen.

Wenn jemand weiß, wie man das in C ++ macht, interessiert mich die Antwort sehr. Ich würde mich sogar über etwas freuen, das sich darauf stützt, dass zum Beispiel alle Ausnahmen, die von einer einzelnen Klasse mit einigen besonderen Fähigkeiten geerbt wurden, durchgesetzt werden.