/EH (Ausnahmebehandlungsmodell)/EH (Exception handling model)

Gibt die vom Compiler generierte Ausnahme Behandlungsmodell Unterstützung an.Specifies the exception handling model support generated by the compiler. Mit Argumenten wird angegeben, ob eine :::no-loc(catch):::(...) Syntax auf strukturierte und standardmäßige C++-Ausnahmen angewendet werden soll, ob ** :::no-loc(extern)::: "C"** -Code :::no-loc(throw)::: Ausnahmen angenommen werden und ob bestimmte Überprüfungen entfernt werden sollen :::no-loc(noexcept)::: .Arguments specify whether to apply :::no-loc(catch):::(...) syntax to both structured and standard C++ exceptions, whether :::no-loc(extern)::: "C" code is assumed to :::no-loc(throw)::: exceptions, and whether to optimize away certain :::no-loc(noexcept)::: checks.

SyntaxSyntax

/EHa[-]/EHa[-]
/EHs[-]/EHs[-]
/EHc[-]/EHc[-]
/EHr[-]/EHr[-]

ArgumenteArguments

a
Aktiviert die standardmäßige C++-Stapel Entwicklung.Enables standard C++ stack unwinding. Fängt bei Verwendung von Syntax sowohl strukturierte (asynchrone) als auch C++ (synchrone) Standard Ausnahmen ab :::no-loc(catch):::(...) .Catches both structured (asynchronous) and standard C++ (synchronous) exceptions when you use :::no-loc(catch):::(...) syntax. /EHa Überschreibt beide /EHs -und- /EHc Argumente./EHa overrides both /EHs and /EHc arguments.

s
Aktiviert die standardmäßige C++-Stapel Entwicklung.Enables standard C++ stack unwinding. Fängt nur bei Verwendung von Syntax Standard-C++-Ausnahmen ab :::no-loc(catch):::(...) .Catches only standard C++ exceptions when you use :::no-loc(catch):::(...) syntax. Sofern nicht /EHc auch angegeben wird, geht der Compiler davon aus, dass als ** :::no-loc(extern)::: "C"** deklarierte Funktionen :::no-loc(throw)::: eine C++-Ausnahme darstellen dürfen.Unless /EHc is also specified, the compiler assumes that functions declared as :::no-loc(extern)::: "C" may :::no-loc(throw)::: a C++ exception.

c
Bei Verwendung mit /EHs geht der Compiler davon aus, dass Funktionen, die als ** :::no-loc(extern)::: "C"** deklariert sind, niemals :::no-loc(throw)::: eine C++-Ausnahme sind.When used with /EHs, the compiler assumes that functions declared as :::no-loc(extern)::: "C" never :::no-loc(throw)::: a C++ exception. Sie hat keine Auswirkung, wenn Sie mit verwendet wird /EHa (das heißt, /EHca ist äquivalent zu /EHa ).It has no effect when used with /EHa (that is, /EHca is equivalent to /EHa). /EHc wird ignoriert, wenn /EHs oder /EHa nicht angegeben ist./EHc is ignored if /EHs or /EHa aren't specified.

r
Weist den Compiler an, immer Lauf Zeit Beendigungs Prüfungen für alle Funktionen zu generieren :::no-loc(noexcept)::: .Tells the compiler to always generate runtime termination checks for all :::no-loc(noexcept)::: functions. Standardmäßig können Lauf Zeit Prüfungen für :::no-loc(noexcept)::: optimiert werden, wenn der Compiler feststellt, dass die Funktion nur Funktionen aufruft, die keine :::no-loc(throw)::: Funktionen sind.By default, runtime checks for :::no-loc(noexcept)::: may be optimized away if the compiler determines the function calls only non-:::no-loc(throw):::ing functions. Diese Option bietet strikte C++-Konformität mit den Kosten für zusätzlichen Code.This option gives strict C++ conformance at the cost of some extra code. /EHr wird ignoriert, wenn /EHs oder /EHa nicht angegeben ist./EHr is ignored if /EHs or /EHa aren't specified.

-
Löscht das vorherige options Argument.Clears the previous option argument. Beispielsweise /EHsc- wird als interpretiert /EHs /EHc- , und entspricht /EHs .For example, /EHsc- is interpreted as /EHs /EHc-, and is equivalent to /EHs.

/EH Argumente können in beliebiger Reihenfolge separat oder kombiniert angegeben werden./EH arguments may be specified separately or combined, in any order. Wenn mehr als eine Instanz desselben Arguments angegeben wird, überschreibt der letzte alle früheren Instanzen.If more than one instance of the same argument is specified, the last one overrides any earlier ones. Beispielsweise /EHr- /EHc /EHs ist identisch mit /EHscr- und /EHscr- /EHr hat denselben Effekt wie /EHscr .For example, /EHr- /EHc /EHs is the same as /EHscr-, and /EHscr- /EHr has the same effect as /EHscr.

BemerkungenRemarks

Standardverhalten bei der AusnahmebehandlungDefault exception handling behavior

Der Compiler generiert immer Code, der die asynchrone strukturierte Ausnahmebehandlung () unterstützt :::no-loc(SEH)::: .The compiler always generates code that supports asynchronous structured exception handling (:::no-loc(SEH):::). Wenn keine /EHsc ,- /EHs oder- /EHa Option angegeben ist, unterstützt der Compiler standardmäßig :::no-loc(SEH)::: Handler in der nativen C++- :::no-loc(catch):::(...) Klausel.By default (that is, if no /EHsc, /EHs, or /EHa option is specified), the compiler supports :::no-loc(SEH)::: handlers in the native C++ :::no-loc(catch):::(...) clause. Es generiert jedoch auch Code, der nur teilweise C++-Ausnahmen unterstützt.However, it also generates code that only partially supports C++ exceptions. Der standardmäßige Entwicklungscode für Ausnahmen zerstört keine automatischen C++-Objekte außerhalb von :::no-loc(try)::: Blöcken, die aufgrund einer Ausnahme außerhalb des Gültigkeits Bereichs liegen.The default exception unwinding code doesn't destroy automatic C++ objects outside of :::no-loc(try)::: blocks that go out of scope because of an exception. Ressourcen Lecks und undefiniertes Verhalten können ergeben, wenn eine C++-Ausnahme :::no-loc(throw)::: n ist.Resource leaks and undefined behavior may result when a C++ exception is :::no-loc(throw):::n.

Standard mäßige C++-AusnahmebehandlungStandard C++ exception handling

Vollständige Compilerunterstützung für das Standard mäßige C++-Ausnahme Behandlungsmodell, das Stapel Objekte sicher entlädt, erfordert /EHsc (empfohlen), /EHs oder /EHa .Full compiler support for the Standard C++ exception handling model that safely unwinds stack objects requires /EHsc (recommended), /EHs, or /EHa.

Wenn Sie /EHs oder verwenden /EHsc , dann sind Ihre- :::no-loc(catch):::(...) Klauseln keine :::no-loc(catch)::: asynchronen strukturierten Ausnahmen.If you use /EHs or /EHsc, then your :::no-loc(catch):::(...) clauses don't :::no-loc(catch)::: asynchronous structured exceptions. Alle Zugriffs Verletzungen und verwalteten System.Exception Ausnahmen werden nicht abgefangen.Any access violations and managed System.Exception exceptions go uncaught. Außerdem werden Objekte im Bereich, wenn eine asynchrone Ausnahme auftritt, nicht zerstört, auch wenn der Code die asynchrone Ausnahme behandelt.And, objects in scope when an asynchronous exception occurs aren't destroyed, even if the code handles the asynchronous exception. Dieses Verhalten ist ein Argument, mit dem strukturierte Ausnahmen nicht behandelt werden.This behavior is an argument for leaving structured exceptions unhandled. Beachten Sie stattdessen, dass diese Ausnahmen schwerwiegend sind.Instead, consider these exceptions fatal.

Wenn Sie /EHs oder verwenden /EHsc , geht der Compiler davon aus, dass Ausnahmen nur bei einer- :::no-loc(throw)::: Anweisung oder bei einem Funktions aufzurufen auftreten können.When you use /EHs or /EHsc, the compiler assumes that exceptions can only occur at a :::no-loc(throw)::: statement or at a function call. Diese Annahme ermöglicht es dem Compiler, Code zum Nachverfolgen der Lebensdauer von vielen nicht windable-Objekten auszuschließen, wodurch die Codegröße erheblich reduziert werden kann.This assumption allows the compiler to eliminate code for tracking the lifetime of many unwindable objects, which can significantly reduce code size. Wenn Sie verwenden /EHa , kann das ausführbare Image größer und langsamer sein, da der Compiler :::no-loc(try)::: Blöcke nicht als aggressiv optimiert.If you use /EHa, your executable image may be larger and slower, because the compiler doesn't optimize :::no-loc(try)::: blocks as aggressively. Außerdem gibt es Ausnahme Filter, die lokale Objekte automatisch bereinigen, auch wenn der Compiler keinen Code sieht, der :::no-loc(throw)::: eine C++-Ausnahme haben kann.It also leaves in exception filters that automatically clean up local objects, even if the compiler doesn't see any code that can :::no-loc(throw)::: a C++ exception.

Strukturierte und standardmäßige C++-AusnahmebehandlungStructured and standard C++ exception handling

Die /EHa -Compileroption ermöglicht eine sichere Stapel Auflösung für asynchrone Ausnahmen und C++-Ausnahmen.The /EHa compiler option enables safe stack unwinding for both asynchronous exceptions and C++ exceptions. Sie unterstützt die Behandlung von standardmäßigen C++-und strukturierten Ausnahmen mithilfe der nativen C++- :::no-loc(catch):::(...) Klausel.It supports handling of both standard C++ and structured exceptions by using the native C++ :::no-loc(catch):::(...) clause. Wenn :::no-loc(SEH)::: Sie ohne Angabe von implementieren möchten /EHa , können Sie die **__ :::no-loc(try)::: **-, __except -und- __:::no-loc(finally)::: Syntax verwenden.To implement :::no-loc(SEH)::: without specifying /EHa, you may use the __:::no-loc(try):::, __except, and __:::no-loc(finally)::: syntax. Weitere Informationen finden Sie unter strukturierte Ausnahmebehandlung.For more information, see Structured exception handling.

Wichtig

Das angeben /EHa und angeben :::no-loc(try)::: , um alle Ausnahmen mithilfe von zu verarbeiten, :::no-loc(catch):::(...) kann gefährlich sein.Specifying /EHa and :::no-loc(try):::ing to handle all exceptions by using :::no-loc(catch):::(...) can be dangerous. Da asynchrone Ausnahmen größtenteils nicht behebbar sind, gelten sie als schwerwiegende Ausnahmen.In most cases, asynchronous exceptions are unrecoverable and should be considered fatal. Wenn Sie sie abfangen und den Prozess anschließend fortsetzen, können Beschädigungen und Fehler auftreten, die schwer zu finden und zu beheben sind.Catching them and proceeding can cause process corruption and lead to bugs that are hard to find and fix.

Obwohl Windows und Visual C++ unterstützt :::no-loc(SEH)::: werden, wird dringend empfohlen, die ISO-Standard-C++-Ausnahmebehandlung ( /EHsc oder) zu verwenden /EHs .Even though Windows and Visual C++ support :::no-loc(SEH):::, we strongly recommend that you use ISO-standard C++ exception handling (/EHsc or /EHs). Dadurch wird Ihr Code portabler und flexibler.It makes your code more portable and flexible. Manchmal müssen Sie :::no-loc(SEH)::: in Legacy Code oder für bestimmte Arten von Programmen verwenden.There may still be times you have to use :::no-loc(SEH)::: in legacy code or for particular kinds of programs. Dies ist beispielsweise erforderlich, wenn Code zur Unterstützung der Common Language Runtime (/CLR) kompiliert ist.It's required in code compiled to support the common language runtime (/clr), for example. Weitere Informationen finden Sie unter strukturierte Ausnahmebehandlung.For more information, see Structured exception handling.

Es wird empfohlen, dass Sie die mit kompilierten Objektdateien niemals mit den Dateien verknüpfen, /EHa /EHs die mit oder /EHsc im selben ausführbaren Modul kompiliert wurden.We recommend that you never link object files compiled using /EHa to ones compiled using /EHs or /EHsc in the same executable module. Wenn Sie eine asynchrone Ausnahme behandeln müssen, indem Sie eine beliebige Stelle /EHa in Ihrem Modul verwenden, kompilieren Sie mithilfe von /EHa den gesamten Code im Modul.If you have to handle an asynchronous exception by using /EHa anywhere in your module, use /EHa to compile all the code in the module. Sie können die Syntax für die strukturierte Ausnahmebehandlung im selben Modul wie Code verwenden, der mit kompiliert wurde /EHs .You can use structured exception handling syntax in the same module as code that's compiled by using /EHs. Die Syntax kann jedoch nicht :::no-loc(SEH)::: mit C++ :::no-loc(try)::: , :::no-loc(throw)::: und :::no-loc(catch)::: in derselben Funktion gemischt werden.However, you can't mix the :::no-loc(SEH)::: syntax with C++ :::no-loc(try):::, :::no-loc(throw):::, and :::no-loc(catch)::: in the same function.

Verwenden /EHa Sie, wenn Sie :::no-loc(catch)::: eine Ausnahme verwenden möchten, die von einem anderen als einem ausgelöst wird :::no-loc(throw)::: .Use /EHa if you want to :::no-loc(catch)::: an exception that's raised by something other than a :::no-loc(throw):::. In diesem Beispiel wird :::no-loc(catch)::: eine strukturierte Ausnahme generiert und erstellt:This example generates and :::no-loc(catch):::es a structured exception:

// compiler_options_EHA.cpp
// compile with: /EHa
#include <iostream>
#include <excpt.h>
using namespace std;

void fail()
{
    // generates SE and attempts to :::no-loc(catch)::: it using :::no-loc(catch):::(...)
    :::no-loc(try):::
    {
        int i = 0, j = 1;
        j /= i;   // This will :::no-loc(throw)::: a SE (divide by zero).
        printf("%d", j);
    }
    :::no-loc(catch):::(...)
    {
        // :::no-loc(catch)::: block will only be executed under /EHa
        cout << "Caught an exception in :::no-loc(catch):::(...)." << endl;
    }
}

int main()
{
    __:::no-loc(try):::
    {
        fail();
    }

    // __except will only :::no-loc(catch)::: an exception here
    __except(EXCEPTION_EXECUTE_HANDLER)
    {
        // if the exception was not caught by the :::no-loc(catch):::(...) inside fail()
        cout << "An exception was caught in __except." << endl;
    }
}

Ausnahmebehandlung unter/CLRException handling under /clr

Die /clr Option impliziert /EHa (d. h /clr /EHa . ist redundant).The /clr option implies /EHa (that is, /clr /EHa is redundant). Der Compiler generiert einen Fehler, wenn /EHs oder /EHsc nach verwendet wird /clr .The compiler generates an error if /EHs or /EHsc is used after /clr. Optimierungen wirken sich nicht auf dieses Verhalten aus.Optimizations don't affect this behavior. Wenn eine Ausnahme abgefangen wird, ruft der Compiler die klassendefiktoren für alle Objekte auf, die sich im gleichen Bereich wie die Ausnahme befinden.When an exception is caught, the compiler invokes the class destructors for any objects that are in the same scope as the exception. Wenn eine Ausnahme nicht abgefangen wird, werden diese debugtoren nicht ausgeführt.If an exception isn't caught, those destructors aren't run.

Informationen zu Ausnahme Behandlungs Einschränkungen unter /clr finden Sie unter _set_se_translator.For information about exception handling restrictions under /clr, see _set_se_translator.

Lauf Zeit Ausnahme ÜberprüfungenRuntime exception checks

Die- /EHr Option erzwingt Lauf Zeit Abbruch Prüfungen in allen Funktionen, die über ein- :::no-loc(noexcept)::: Attribut verfügen.The /EHr option forces runtime termination checks in all functions that have a :::no-loc(noexcept)::: attribute. Standardmäßig können Laufzeitüberprüfungen entfernt werden, wenn das Compiler-Back-End feststellt, dass eine Funktion nur *nicht- :::no-loc(throw)::: * Funktionen aufruft.By default, runtime checks may be optimized away if the compiler back-end determines that a function only calls non-:::no-loc(throw):::ing functions. :::no-loc(throw):::Nichtingfunktionen sind Funktionen, die über ein Attribut verfügen, das angibt, dass keine Ausnahmen n sein können :::no-loc(throw)::: .Non-:::no-loc(throw):::ing functions are any functions that have an attribute that specifies no exceptions may be :::no-loc(throw):::n. Sie umfassen Funktionen, die mit,, und gekennzeichnet sind, :::no-loc(noexcept)::: :::no-loc(throw):::() __declspec(no:::no-loc(throw):::) Wenn /EHc angegeben wird, ** :::no-loc(extern)::: "C"** -Funktionen.They include functions marked :::no-loc(noexcept):::, :::no-loc(throw):::(), __declspec(no:::no-loc(throw):::), and, when /EHc is specified, :::no-loc(extern)::: "C" functions. Zu :::no-loc(throw)::: den Funktionen, die der Compiler bestimmt hat, sind auch alle, die der Compiler bei der Überprüfung nicht erschließt :::no-loc(throw)::: .Non-:::no-loc(throw):::ing functions also include any that the compiler has determined are non-:::no-loc(throw):::ing by inspection. Sie können das Standardverhalten mithilfe von explizit festlegen /EHr- .You can explicitly set the default behavior by using /EHr-.

Ein :::no-loc(throw)::: nichtingattribut ist keine Garantie dafür, dass Ausnahmen nicht :::no-loc(throw)::: von einer Funktion n sein können.A non-:::no-loc(throw):::ing attribute isn't a guarantee that exceptions can't be :::no-loc(throw):::n by a function. Im Gegensatz zum Verhalten einer :::no-loc(noexcept)::: Funktion betrachtet der MSVC-Compiler eine Ausnahme :::no-loc(throw)::: n durch eine Funktion, die mit :::no-loc(throw):::() , __declspec(no:::no-loc(throw):::) oder ** :::no-loc(extern)::: "C"** als nicht definiertes Verhalten deklariert wurde.Unlike the behavior of a :::no-loc(noexcept)::: function, the MSVC compiler considers an exception :::no-loc(throw):::n by a function declared using :::no-loc(throw):::(), __declspec(no:::no-loc(throw):::), or :::no-loc(extern)::: "C" as undefined behavior. Funktionen, die diese drei Deklarations Attribute verwenden, erzwingen keine Lauf Zeit Beendigungs Prüfungen für Ausnahmen.Functions that use these three declaration attributes don't enforce runtime termination checks for exceptions. Sie können die- /EHr Option verwenden, um dieses nicht definierte Verhalten zu identifizieren, indem Sie erzwingen, dass der Compiler Lauf Zeit Prüfungen für nicht behandelte Ausnahmen generiert, die eine Funktion mit Escapezeichen versehen :::no-loc(noexcept)::: .You can use the /EHr option to help you identify this undefined behavior, by forcing the compiler to generate runtime checks for unhandled exceptions that escape a :::no-loc(noexcept)::: function.

Festlegen der Option in Visual Studio oder Programm gesteuertSet the option in Visual Studio or programmatically

So legen Sie diese Compileroption in der Visual Studio-Entwicklungsumgebung festTo set this compiler option in the Visual Studio development environment

  1. Öffnen Sie das Dialogfeld Eigenschaftenseiten des Projekts.Open the project's Property Pages dialog box. Weitere Informationen erhalten Sie unter Set C++ compiler and build properties in Visual Studio (Festlegen der Compiler- und Buildeigenschaften (C++) in Visual Studio).For details, see Set C++ compiler and build properties in Visual Studio.

  2. Wählen Sie Konfigurations Eigenschaften > C/C++- > Code Generierungaus.Select Configuration Properties > C/C++ > Code Generation.

  3. Ändern Sie die Eigenschaft C++-Ausnahmen aktivieren .Modify the Enable C++ Exceptions property.

    Oder legen Sie den Wert für C++-Ausnahmen aktivieren auf Neinfest, und fügen Sie dann auf der Eigenschaftenseite Befehlszeile im Feld Zusätzliche Optionen die Compileroption hinzu.Or, set Enable C++ Exceptions to No, and then on the Command Line property page, in the Additional Options box, add the compiler option.

So legen Sie diese Compileroption programmgesteuert festTo set this compiler option programmatically

Siehe auchSee also

MSVC-CompileroptionenMSVC Compiler Options
MSVC-compilerbefehlszeilensyntaxMSVC Compiler Command-Line Syntax
Fehler-und AusnahmebehandlungErrors and Exception Handling
Ausnahme Spezifikationen ( :::no-loc(throw)::: )Exception Specifications (:::no-loc(throw):::)
Structured Exception Handling (C/C++)Structured Exception Handling (C/C++)