Passaggio di eccezioni attraverso un limite API C

Question

Sto scrivendo una libreria in C++ che utilizza un'API C precedente. Il client della mia libreria può specificare funzioni di callback, che vengono chiamate indirettamente attraverso la mia libreria che viene chiamata attraverso l'API C. Ciò significa che tutte le eccezioni nei callback del client devono essere gestite.

La mia domanda è questa: come posso catturare l'eccezione su un lato del confine e rilanciarlo una volta che il limite dell'API C è stato riattraversato e l'esecuzione è tornata in C++ land in modo che l'eccezione possa essere gestita da codice cliente?

Answer 1

Con C++ 11 Potremmo usare:

std::exception_ptr active_exception; 

try 
{ 
    // call code which may throw exceptions 
} 
catch (...) 
{ 
    // an exception is thrown. save it for future re-throwing. 
    active_exception = std::current_exception(); 
} 

// call C code 
... 

// back to C++, re-throw the exception if needed. 
if (active_exception) 
    std::rethrow_exception(active_exception); 

Prima di C++ 11 questi possono ancora essere utilizzati tramite Boost Exception.

Answer 2

Probabilmente è possibile passare una struttura nell'interfaccia C che viene riempita con informazioni di errore in caso di un'eccezione e quindi quando viene ricevuta sul lato client, controllarla e generare un'eccezione all'interno del client, in base ai dati dalla struttura. Se hai solo bisogno di informazioni minime per ricreare la tua eccezione, probabilmente puoi semplicemente usare un numero intero a 32-bit/64-bit come codice di errore. Per esempio:

typedef int ErrorCode; 

... 

void CMyCaller::CallsClient() 
{ 
    CheckResult (CFunction (...)); 
} 

void CheckResult (ErrorCode nResult) 
{ 
    // If you have more information (for example in a structure) then you can 
    // use that to decide what kind of exception to throw.) 
    if (nResult < 0) 
     throw (nResult); 
} 

... 

// Client component's C interface 

ErrorCode CFunction (...) 
{ 
    ErrorCode nResult = 0; 

    try 
    { 
     ... 
    } 
    catch (CSomeException oX) 
    { 
     nResult = -100; 
    } 
    catch (...) 
    { 
     nResult = -1; 
    } 

    return (nResult); 
} 

Se avete bisogno di più informazioni di un singolo Int32/Int64 allora si può allocare una struttura di prima della chiamata e passare il suo indirizzo alla funzione C che, a sua volta, intercettare le eccezioni internamente e se succede, genera un'eccezione dalla sua parte.

Answer 3

Alcuni ambienti supportano questo più o meno direttamente.

Ad esempio, se si abilitano le eccezioni structured exception handling e C++ tramite lo switch del compilatore /EH, è possibile implementare eccezioni C++ rispetto alla gestione strutturata delle eccezioni di Microsoft ("eccezioni" per C). A condizione che queste opzioni siano impostate quando si compila tutto il codice (il C++ a ciascuna estremità e la C al centro) lo stack che si svolge si "lavora".

Tuttavia, questa è quasi sempre una cattiva idea (TM). Perché, chiedi? Si consideri che il pezzo di codice C in mezzo è:

WaitForSingleObject(mutex, ...); 
invoke_cxx_callback(...); 
ReleaseMutex(mutex); 

E che la invoke_cxx_callback() (.... rullo di tamburi ...) invoca il tuo codice C++ che genera un'eccezione. Perderai un blocco mutex. Ahia.

Vedete, il fatto è che la maggior parte del codice C non è scritta per gestire C++ - stack di stile che si svolge in qualsiasi momento nell'esecuzione di una funzione. Inoltre, manca di distruttori, quindi non ha RAII per proteggersi dalle eccezioni.

Kenny TM ha una soluzione per C++ 11 e progetti basati su Boost. xxbbcc ha una soluzione più generale, anche se più noiosa per il caso generale.