Richtig beenden das Programm. Mit Ausnahmen

Es ist allgemein als gute Praxis, dass alle Ausnahmen propagieren durch main. Dies ist in Erster Linie, weil Sie sicher sein können, dass der stack korrekt abgewickelt und alle Destruktoren aufgerufen werden (siehe diese Antwort). Ich denke auch, es ist mehr organisiert, Dinge zu tun, auf diese Weise; Sie wusste immer, wo Sie Ihr Programm beendet (es sei denn, das Programm stürzt ab). Es erleichtert auch die weitere konsequente error reporting (ein Punkt, der oft vernachlässigt wird in der Ausnahmebehandlung; wenn Sie kann nicht mit der Ausnahme, sollten Sie sicherstellen, dass Ihre Anwender genau weiß, warum). Wenn Sie beginnen immer mit diesem Basis-layout

int main(int argc, const char **argv)
{
    try {
         //do stuff
         return EXIT_SUCCESS;
    } catch (...) {
        std::cerr << "Error: unknown exception" << std::endl;
        return EXIT_FAILURE;
    }
}

dann wirst du nicht viel falsch machen. Sie können (und sollten) auch spezifische catch Aussagen für eine bessere error-reporting.

Ausnahmen, wenn multithreading

Es gibt zwei grundlegende Arten von asynchron ausgeführten code in C++11 standard-Bibliothek features: std::async und std::thread.

Zuerst die einfache. std::async zurück std::future dem erfassen und speichern keine nicht abgefangene Ausnahmen, die in der gegebenen Funktion. Aufruf std::future::get auf die Zukunft führt dazu, Ausnahmen zu propagieren und in die aufrufende thread.

auto fut = std::async(std::launch::async, [] () { throw std::runtime_error {"oh dear"}; });
fut.get(); //fine, throws exception

Auf der anderen Seite, wenn eine Ausnahme in einer std::thread Objekt nicht erfasst wird, dann std::terminate werden genannt:

try {
    std::thread t {[] () { throw std::runtime_error {"oh dear"};}};
    t.join();
} catch(...) {
    //only get here if std::thread constructor throws
}

Eine Lösung könnte sein, passieren eine std::exception_ptr in die std::thread Objekt, das Sie übergeben können, die Ausnahme:

void foo(std::exception_ptr& eptr)
{
    try {
        throw std::runtime_error {"oh dear"};
    } catch (...) {
        eptr = std::current_exception();
    }
}

void bar()
{
    std::exception_ptr eptr {};

    std::thread t {foo, std::ref(eptr)};

    try {
        //do stuff
    } catch(...) {
        t.join(); //t may also have thrown
        throw;
    }
    t.join();

    if (eptr) {
        std::rethrow_exception(eptr);
    }
}

Obwohl eine bessere Möglichkeit ist die Verwendung std::package_task:

void foo()
{
    throw std::runtime_error {"oh dear"};
}

void bar()
{
    std::packaged_task<void()> task {foo};
    auto fut = task.get_future();

    std::thread t {std::move(task)};
    t.join();

    auto result = fut.get(); //throws here
}

Aber es sei denn, Sie haben guten Grund für die Verwendung std::thread lieber std::async.

Sie bereits akzeptiert haben, eine Antwort, aber ich wollte noch etwas dazu:

Kann ich nur ausdrücklich nennen so etwas wie exit() statt?

Können Sie Anruf beenden, aber (wahrscheinlich) nicht.

std::exit reserviert werden soll für Situationen, in denen Sie zum Ausdruck bringen wollen "Ausstieg jetzt!", nicht einfach nur "Anwendung hat nichts zu tun".

Als ein Beispiel, wenn Sie schreiben, eine Steuerung für einen laser verwendet in der Behandlung von Krebs, Ihre erste Priorität in dem Fall, dass etwas schief ging, wäre ein Herunterfahren der laser-und call - std::exit - oder vielleicht std::terminate (um sicherzustellen, dass alle Nebenwirkungen einer hängenden, langsam oder Absturz der Anwendung nicht zu töten, ein patient).

Ähnlich wie die Ausnahmen sollten nicht verwendet werden für die Steuerung von Anwendung fließen, exit sollte nicht verwendet werden, um die Anwendung zu beenden unter normalen Bedingungen.

Aus der Dokumentation:

[[noreturn]] void exit (int status);
Kündigen aufrufenden Prozesses
Beendet den Prozess Regel, die Durchführung der regelmäßigen Bereinigung für die Beendigung von Programmen.

Normalen Beendigung des Programms führt die folgenden (in der gleichen Reihenfolge):
Objekte im Zusammenhang mit dem aktuellen thread mit thread Lagerung Dauer zerstört werden (C++11).
Objekte mit statischen Speicher Dauer zerstört werden (C++) und registrierten Funktionen, die mit atexit aufgerufen werden.
Alle C-streams (öffnen mit Funktionen ) sind geschlossen (und geleert, wenn gepuffert), und alle Dateien erstellt mit tmpfile entfernt werden.
Die Kontrolle wird zurück an die host-Umgebung.

Beachten Sie, dass Objekte mit automatischer Speicherung werden nicht zerstört durch Aufruf von exit (C++).

Wenn status ist null oder EXIT_SUCCESS, einen erfolgreichen Abschluss status zurückgegeben wird, die host-Umgebung.
Wenn status ist EXIT_FAILURE, eine erfolglose Beendigung status zurückgegeben wird, die host-Umgebung.
Andernfalls wird der status zurückgegeben wird, hängt von der system-und library-Umsetzung.

Für eine ähnliche Funktion, die nicht für die Bereinigung oben beschrieben, siehe quick_exit.