Abfangen von Ausnahmen in Visual C++

Artikel
05/08/2022
4 Minuten Lesedauer

In diesem Artikel wird beschrieben, wie Sie einen try-catch-finally Block verwenden, um eine Ausnahme abzufangen.

Originalversion des Produkts: Visual C++
Ursprüngliche KB-Nummer: 815662

Zusammenfassung

Ein try-catch-finally Block ist ein Wrapper, den Sie um jeden Code herum platzieren, in dem eine Ausnahme auftreten kann. Das Abfangen und Behandeln von Ausnahmen sind Standardprogrammieraufgaben.

Ein try-catch-finally Block besteht aus den folgenden Abschnitten:

Jeder Code, der eine Ausnahme auslösen kann, wird innerhalb des Try-Blocks platziert.
Wenn eine Ausnahme ausgelöst wird, wird der catch Block eingegeben, und das Programm kann den entsprechenden Vorgang ausführen, um den Benutzer wiederherzustellen oder zu benachrichtigen.
Der Code im finally Block wird immer ausgeführt und kann bereinigt werden, nachdem eine Ausnahme aufgetreten ist. Der finally Block ist optional.

Dieser Artikel bezieht sich auf die folgenden Microsoft .NET Framework Class Library-Namespaces: System.IO und System.Security.

Abfangen von Ausnahmen in Visual C++ .NET

Starten Sie Visual Studio .NET.
Zeigen Sie im Menü Datei auf Neu, und klicken Sie dann auf Projekt.
Klicken Sie in Visual C++ unter Project Typen auf Visual C++, und klicken Sie dann unter "Vorlagen" auf "CLR-Konsolenanwendung".
Geben Sie im Feld "Name " Q815662 ein, und klicken Sie dann auf "OK".

Ersetzen Sie den gesamten Code im Codefenster "Q815662.cpp " durch den folgenden Code. Der Code deklariert und initialisiert drei Variablen. Die Initialisierung von k verursacht einen Fehler.

#include "stdafx.h"
#using <mscorlib.dll>
#include <tchar.h>
using namespace System;
void _tmain(void)
{
    Console::WriteLine("We're going to divide 10 by 0 and see what happens...");
    Console::WriteLine();
    int i = 10;
    int j = 0;
    int k = i/j; //Error on this line.
}

Drücken Sie F5. Sie erhalten eine System.DivideByZeroException Ausnahme.

Umschließen Sie eine try-catch Anweisung um ihren Code, um den Fehler zu erfassen. Der folgende Code fängt alle Fehler ab, die im Code ausgelöst werden, und zeigt eine generische Fehlermeldung an. Ersetzen Sie den Code im Codefenster "Q815662.cpp " durch den folgenden Code:

#include "stdafx.h"
#using <mscorlib.dll>
#include <tchar.h>
using namespace System;
void _tmain(void)
{
    try
    {
        Console::WriteLine("We're going to divide 10 by 0 and see what happens...");
        Console::WriteLine();
        int i = 10;
        int j = 0;
        int k = i/j; //Error on this line.
    }
    catch(...)
    {
        Console::WriteLine("An error occurred.");
    }
}

Drücken Sie STRG+F5, um die Anwendung auszuführen.

Hinweis

Die Fehlermeldung aus dem catch Block wird anstelle der Systemfehlermeldung angezeigt.

Wenn Sie die Bereinigung oder Nachbearbeitung unabhängig von einem Fehler durchführen müssen, verwenden Sie den __finally Teil der try-catch-finally Anweisung. Der Code im letzten Teil der Anweisung wird immer ausgeführt, unabhängig von einer Ausnahme. Der folgende Code zeigt die folgende Meldung in der Konsole an, auch wenn kein Fehler aufgetreten ist:

This statement is always printed.

Ersetzen Sie den Code im Codefenster "Q815662.cpp " durch den folgenden Code:

#include "stdafx.h"
#using <mscorlib.dll>
#include <tchar.h>
using namespace System;
void _tmain(void)
{
    try
    {
        Console::WriteLine("We're going to divide 10 by 0 and see what happens...");
        Console::WriteLine();
        int i = 10;
        int j = 0;
        int k = i/j; //Error on this line.
    }
    catch(...)
    {
        Console::WriteLine("An error occurred.");
    }
    __finally //This section is performed regardless of the above processing.
    {
        Console::WriteLine();
        Console::WriteLine("This statement is always printed");
    }
}

Drücken Sie STRG+F5, um das Projekt auszuführen.

Sie können das Ausnahmeobjekt mit der catch-Anweisung verwenden, um Details zur Ausnahme abzurufen. Ein Ausnahmeobjekt verfügt über eine Reihe von Eigenschaften, die Ihnen helfen können, die Quelle zu identifizieren, und verfügt über Stapelinformationen zu einer Ausnahme. Diese Informationen können hilfreich sein, um die ursprüngliche Ursache der Ausnahme nachzuverfolgen, oder sie können eine bessere Erklärung der Quelle liefern. Im folgenden Beispiel wird eine Ausnahme erfasst und eine bestimmte Fehlermeldung angezeigt. Ersetzen Sie den Code im Codefenster "Q815662.cpp " durch den folgenden Code:

#include "stdafx.h"
#using <mscorlib.dll>
#include <tchar.h>
using namespace System;
using namespace System::Reflection;
void _tmain(void)
{
    try
    {
        Console::WriteLine("We're going to divide 10 by 0 and see what happens...");
        Console::WriteLine();
        int i = 10;
        int j = 0;
        int k = i/j; //Error on this line.
    }
    catch(Exception *e)
    {
        Console::WriteLine("An error occurred.");
        Console::WriteLine(e->Message); // Print the error message.
        Console::WriteLine(e->StackTrace); //String that contains the stack trace for this exception.
    }
    __finally //This section is performed regardless of the above processing.
    {
        Console::WriteLine();
        Console::WriteLine("This statement is always printed");
    }
    Console::ReadLine();
}

Bis zu diesem Punkt haben Sie sich mit einer nicht spezifischen Ausnahme befasst. Wenn Sie jedoch im Voraus wissen, welche Art von Ausnahme auftreten wird, können Sie die erwartete Ausnahme abfangen und entsprechend verarbeiten. Verwenden Sie die im folgenden Code beschriebenen mehreren Abfangblöcke, um alle anderen Ausnahmen abfangen und behandeln zu können:

#include "stdafx.h"
#using <mscorlib.dll>
#include <tchar.h>
using namespace System;
using namespace System::IO;
using namespace System::Security;
void _tmain(void)
{
    try
    {
        File::Create("c:\\temp\\testapp.txt"); //Can fail for a number of resons
    }
    // This error may occur if the temp folder does not exist.
    catch(IOException *ioe)
    {
        Console::WriteLine("An IOException exception occurred!");
        Console::WriteLine(ioe->ToString());
    }
    // You do not have the appropriate permission to take this action.
    catch(SecurityException *se)
    {
        Console::WriteLine("An SecurityException exception occur")
    }
    // Catch all exceptions
    catch(Exception *e)
    {
        Console::WriteLine(e->ToString());
    }
}

Da die Computerkonfigurationen möglicherweise unterschiedlich sind, löst das Beispiel in diesem Schritt möglicherweise eine Ausnahme aus. Wenn Sie eine Eingabe-/Ausgabeausnahme erzwingen möchten, ändern Sie den Dateipfad in einen Ordner, der auf Ihrem Computer nicht vorhanden ist.