Perché il C ++ standard non rispetta le eccezioni del sistema (straniero o hardware)?
es. quando si verifica un dereferenziamento del puntatore nullo, lo stack non viene svolto, i distruttori non vengono chiamati e RAII non funziona.
Il consiglio comune è "usare l'API di sistema". Ma su alcuni sistemi, in particolare su Win32, questo non funziona. Per abilitare lo sbobinamento dello stack per questo codice C ++
// class Foo;
// void bar(const Foo&);
bar(Foo(1, 2));
si dovrebbe generare qualcosa come questo codice C
Foo tempFoo;
Foo_ctor(&tempFoo);
__try {
bar(&tempFoo);
}
__finally {
Foo_dtor(&tempFoo);
}
Foo_dtor(&tempFoo);
ed è impossibile implementarlo come libreria C ++.
UPD: Lo standard non vieta la gestione delle eccezioni di sistema. Ma sembra che compilatori popolari come g ++ non rispettino le eccezioni di sistema su qualsiasi piattaforme solo perché lo standard non richiede questo.
L'unica cosa che voglio - è usare RAII per rendere il codice leggibile e il programma affidabile. Non voglio mettere try \ end hand-crafting attorno ad ogni chiamata a codice sconosciuto. Ad esempio in questo codice riutilizzabile, AbstractA::foo
è un codice sconosciuto:
void func(AbstractA* a, AbstractB* b) {
TempFile file;
a->foo(b, file);
}
Forse uno passerà a func
un'implementazione di AbstractA
, che ogni venerdì non controllerà se b
è NULL, quindi la violazione di accesso avverrà, l'applicazione terminerà e il file temporaneo non verrà eliminato. Quanti mesi di utilizzo soffriranno a causa di questo problema, fino a quando uno degli autori di func
o autore di AbstractA
farà qualcosa con esso?