Catching wszystkich nieobsługiwanych wyjątków C++?

Question

Czy istnieje sposób na wychwycenie wyjątków, które w przeciwnym razie nie są obsługiwane (w tym wyjątki wyrzucane poza blokiem catch)?

Nie przejmuję się wszystkimi normalnymi czynnościami czyszczenia wykonanymi z wyjątkami, tylko że mogę je przechwycić, napisać do log/powiadomić użytkownika i zakończyć program, ponieważ wyjątki w tych przypadkach są ogólnie śmiertelne, nieodwracalne błędy.

coś takiego:

global_catch() 
{ 
    MessageBox(NULL,L"Fatal Error", L"A fatal error has occured. Sorry for any inconvience", MB_ICONERROR); 
    exit(-1); 
} 
global_catch(Exception *except) 
{ 
    MessageBox(NULL,L"Fatal Error", except->ToString(), MB_ICONERROR); 
    exit(-1); 
} 

Answer 1

ten może być stosowany do połowu, nieoczekiwane wyjątki.

Bez bloku try catch, nie sądzę, można złapać wyjątki, tak zorganizować swój program, więc wyjątek kod thowing jest pod kontrolą try/catch.

Answer 2

To, co zawsze robię w głównej()

int main() 
{ 
    try 
    { 
     // Do Work 
    } 
    catch(std::exception const& e) 
    { 
     Log(e.what()); 
     // If you are feeling mad (not in main) you could rethrow! 
    } 
    catch(...) 
    { 
     Log("UNKNOWN EXCEPTION"); 
     // If you are feeling mad (not in main) you could rethrow! 
    } 
} 

Answer 3

Można użyć SetUnhandledExceptionFilter w systemie Windows, który złapie wszystkie nieobsłużonych SEH wyjątki.

Ogólnie będzie to wystarczające dla wszystkich problemów, ponieważ IIRC wszystkie wyjątki C++ są implementowane jako SEH.

Answer 4

Bez żadnego bloku catch, nie będzie żadnych wyjątków. Możesz mieć blok catch (...) w twoim main() (i jego odpowiednik w każdym dodatkowym wątku). W tym bloku catch możesz odzyskać szczegóły wyjątku i możesz coś z nimi zrobić, na przykład rejestrowanie i zamykanie.

Jednak istnieją również wady dotyczące ogólnego bloku catch (...): system stwierdzi, że wyjątek został obsłużony przez ciebie, więc nie daje on więcej pomocy. W systemach Unix/Linux ta pomoc stanowi utworzenie pliku CORE, który można załadować do debuggera i zobaczyć oryginalną lokalizację wyjątku, którego nie dotyczy. Jeśli będziesz go obsługiwać z funkcją catch (...), ta informacja zostanie już utracona.

W systemie Windows nie ma plików CORE, więc sugerowałbym blok catch (...). Od tego bloku, to zazwyczaj wywołać funkcję wskrzesić rzeczywisty wyjątek:

std::string ResurrectException() 
    try { 
     throw; 
    } catch (const std::exception& e) { 
     return e.what(); 
    } catch (your_custom_exception_type& e) { 
     return e.ToString(); 
    } catch(...) { 
     return "Ünknown exception!"; 
    } 
} 


int main() { 
    try { 
     // your code here 
    } catch(...) { 
     std::string message = ResurrectException(); 
     std::cerr << "Fatal exception: " << message << "\n"; 
    } 
} 

Answer 5

Aktualizacja: Obejmuje C++ 98 tylko.

Od More Effective C++ przez Meyers (str. 76), można zdefiniować funkcję, która zostanie wywołana, gdy funkcja wygeneruje wyjątek, który nie jest zdefiniowany przez specyfikację wyjątku.

void convertUnexpected() 
{ 
    // You could redefine the exception here into a known exception 
    // throw UnexpectedException(); 

    // ... or I suppose you could log an error and exit. 
} 

W aplikacji zarejestrować funkcję:

std::set_unexpected(convertUnexpected); 

Twoja funkcja convertUnexpected() będzie uzyskać nazywane jeśli funkcja generuje wyjątek, który nie jest zdefiniowany przez jego specyfikacji wyjątków ... co oznacza to tylko działa, jeśli używasz specyfikacji wyjątków. ; (

Answer 6

Użyj catch (...) we wszystkich twoich wyjątkowych barierach (nie tylko w głównym wątku) Sugeruję, abyś zawsze wracał (...) i przekierowywał standardowe wyjście/błąd do pliku logu, nie możesz zrobić sensownego RTTI na (...).OTOH, kompilator GCC jak wyświetli dość szczegółowy opis o nieobsługiwany wyjątek: rodzaj, wartość, co() itp

Answer 7

Wyjazd std::set_terminate()

Answer 8

Pod warunkiem, że C++ 11 jest dostępny, to podejście może być stosowany (patrz przykład z: http://en.cppreference.com/w/cpp/error/rethrow_exception):

#include <iostream> 
#include <exception> 

void onterminate() { 
    try { 
    auto unknown = std::current_exception(); 
    if (unknown) { 
     std::rethrow_exception(unknown); 
    } else { 
     std::cerr << "normal termination" << std::endl; 
    } 
    } catch (const std::exception& e) { // for proper `std::` exceptions 
    std::cerr << "unexpected exception: " << e.what() << std::endl; 
    } catch (...) { // last resort for things like `throw 1;` 
    std::cerr << "unknown exception" << std::endl; 
    } 
} 

int main() { 
    std::set_terminate(onterminate); // set custom terminate handler 
    // code which may throw... 
    return 0; 
} 

Takie podejście pozwala również na dostosowanie wyjścia konsoli do nieobsłużonych wyjątków: mieć coś takiego

unexpected exception: wrong input parameters 
Aborted 

zamiast tego:

terminate called after throwing an instance of 'std::logic_error' 
    what(): wrong input parameters 
Aborted