Fähigkeiten zur Ausnahmebehandlung für C++-Programme

Die Behandlung von Ausnahmen in C++ bringt einige implizite Einschränkungen auf Sprachebene mit sich, aber in einigen Fällen können Sie diese umgehen. Indem Sie verschiedene Möglichkeiten zum Ausnutzen von Ausnahmen erlernen, können Sie zuverlässigere Anwendungen erstellen. Informationen zur Ausnahmequelle beibehalten Wenn in C++ eine Ausnahme in einem Handler abgefangen wird, sind Informationen über die Ausnahmequelle unbekannt. Die spezifische Quelle der Ausnahme kann viele wichtige Informationen zur besseren Behandlung der Ausnahme liefern oder einige Informationen bereitstellen, die zur späteren Analyse an das Fehlerprotokoll angehängt werden können. Um dieses Problem zu lösen, können Sie während der throw-Anweisung im Konstruktor des Ausnahmeobjekts einen Stack-Trace generieren. ExceptionTracer ist eine Klasse, die dieses Verhalten demonstriert. Listing 1. Generieren eines Stack-Trace im Ausnahmeobjektkonstruktor // Beispielprogramm:

// Compiler: gcc 3.2.3 20030502

// Linux: Red Hat #include

#include

#include /////////// / ///////////////////////////////// Klasse ExceptionTracer

{

public :

ExceptionTracer()

{

void * array[25];

int nSize = backtrace(array, 25);

char ** symbols = backtrace_symbols(array, nSize);

　

for (int i = 0; i < nSize; i++)

{

cout << Symbole[i] << endl;

}; Governance-Signal wann immer es geht Führt eine so unangenehme Aktion aus, dass jedes Mal, wenn der Linux-Kernel ein Signal aussendet, das Signal verarbeitet werden muss. Signalhandler geben normalerweise einige wichtige Ressourcen frei und beenden die Anwendung. In diesem Fall befinden sich alle Objektinstanzen auf dem Stapel in einem unzerstörten Zustand. Wenn diese Signale andererseits in C++-Ausnahmen umgewandelt werden, können Sie deren Konstruktoren ordnungsgemäß aufrufen und mehrere Schichten von Catch-Blöcken anordnen, um diese Signale besser verarbeiten zu können. Die in Listing 2 definierte SignalExceptionClass bietet eine Abstraktion zur Darstellung von C++-Ausnahmen, die vom Kernel signalisiert werden können. SignalTranslator ist eine auf SignalExceptionClass basierende Vorlagenklasse, die normalerweise zum Implementieren der Konvertierung in C++-Ausnahmen verwendet wird. Zu jedem Zeitpunkt kann nur ein Signalhandler ein Signal für einen aktiven Prozess verarbeiten. Daher übernimmt SignalTranslator das Singleton-Entwurfsmuster. Das Gesamtkonzept wird durch die SegmentationFault-Klasse für SIGSEGV und die FloatingPointException-Klasse für SIGFPE demonstriert. Listing 2. Signale in Ausnahmen umwandeln SingleTonTranslator

{

public:

SingleTonTranslator()

{

signal(SignalExceptionClass:: GetSignalNumber(),

SignalHandler);

} static void SignalHandler(int)

{

throw SignalExceptionClass();

}; public:

SignalTranslator()

{

static SingleTonTranslator s_objTranslator;

}

}; // Ein Beispiel für SIGSEGV

class SegmentationFault : public ExceptionTracer, public

Exception

{

public:

static int GetSignalNumber() {return SIGSEGV ;}

}; SignalTranslator // Ein Beispiel für SIGFPE

class FloatingPointException : public ExceptionTracer, public

Ausnahme

{

public:

static int GetSignalNumber() {return SIGFPE;}

}; SignalTranslator >
g_objFloatingPointExceptionTranslator; Governance-Ausnahmen in Konstruktoren und Destruktoren Es ist nicht für jedes ANSI-C++ möglich, Ausnahmen während der Erstellung und Zerstörung globaler (statischer globaler) Variablen abzufangen. Daher empfiehlt ANSI C++ nicht, Ausnahmen in den Konstruktoren und Destruktoren von Klassen auszulösen, deren Instanzen als globale Instanzen (statische globale Instanzen) definiert sein können. Mit anderen Worten: Definieren Sie niemals globale (statische globale) Instanzen für Klassen, deren Konstruktoren und Destruktoren Ausnahmen auslösen können. Unter der Annahme eines bestimmten Compilers und eines bestimmten Systems könnte dies jedoch möglich sein, und glücklicherweise ist dies bei GCC unter Linux genau der Fall. Dies lässt sich anhand der Klasse ExceptionHandler demonstrieren, die ebenfalls das Singleton-Entwurfsmuster übernimmt. Sein Konstruktor registriert einen nicht abgefangenen Handler. Da jeweils nur ein nicht abgefangener Handler einen aktiven Prozess verarbeiten kann, sollte der Konstruktor nur einmal aufgerufen werden, daher das Singleton-Muster. Die globale (statische globale) Instanz von ExceptionHandler sollte definiert werden, bevor die tatsächliche globale (statische globale) Variable in Frage definiert wird. Listing 3. Behandlung von Ausnahmen in der Konstruktorklasse ExceptionHandler


{

private:

class SingleTonHandler

{

public:

SingleTonHandler()

{

set_terminate(Handler);

} static void Handler()

{

// Ausnahme von der Konstruktion/Zerstörung globaler Variablen try

{

// re- throw throw;

}

catch (SegmentationFault &)

{

cout << „SegmentationFault“ << endl;

}

catch (FloatingPointException &)

{

cout << „FloatingPointException“ << endl;

}

catch (...)

{

cout << „Unbekannte Ausnahme“ << endl;

} //wenn dies ein Thread ist, der eine Kernaktivität ausführt

abort();

// sonst, wenn dies ein Thread ist, der zur Bearbeitung von Anfragen verwendet wird

// pthread_exit();

}

}; public:

ExceptionHandler()

{

static SingleTonHandler s_objHandler;

}

}; ////////////////////////////////////////////////////////////////////////////////////// /////////////////////// Klasse A

{

öffentlich:

A()

{

//int i = 0, j = 1/i;

*(int *)0 = 0;

}

}; // Bevor wir eine globale Variable definieren, definieren wir eine Dummy-Instanz

// des ExceptionHandler-Objekts, um sicherzustellen, dass

// ExceptionHandler::SingleTonHandler::SingleTonHandler() 
invoked

ExceptionHandler g_objExceptionHandler;

A g_a; ////////////////////////////////////////////////////////////////////////////////////// /////////////////////// int main(int argc, char* argv[])

{

return 0;

}     处理多线程程序中的异常 有时一些异常没有被捕捉,这将造成进程异常中止不过很多时候,进程包含多个线程,其中少数线程执行核心应用程序逻辑,同时其余线程为外部请求提供服务应用程序崩溃.这一点可能是不受人们欢迎的,因为它会通过向应用程序传送不合法的请求而助长拒绝服务攻击.为了避免这一点 ， ExceptionHandler::SingleTonHandler::Handler() ist ein ExceptionHandler::SingleTonHandler::Handler()处理程序常的时候追踪异常的来源.

·将信号从内核程序转换成 C++ ...理。

以上就是C++程序的异常处理技巧的内容，更多相关文章请关注PHP中文网（www.php.cn）！