O que deve ser considerado ao interagir entre C e C++ no contexto do tratamento de exceções?

Ao interagir entre C e C++ no contexto do tratamento de exceções, deve-se ter em conta:

• Sobreposição de fronteiras de linguagens. As exceções de C++ não podem atravessar as fronteiras de funções com ligação extern "C". Isto leva a um comportamento indefinido.
• Incompatibilidade de mecanismos. C não possui um mecanismo incorporado de tratamento de exceções (como try-catch em C++), confiando em códigos de erro ou setjmp/longjmp.
• Segurança de exceções. O código C++ que chama funções C deve estar preparado para que estas funções C possam não ser seguras para exceções. Elas não chamam os destrutores de objetos locais de C++ ao sair via longjmp.
• Captura de exceções. É necessário usar blocos try-catch de C++ para tratar exceções de C++ antes de chamar funções C ou após retorná-las.
• Transmissão de estado de erro. As funções C devem retornar códigos de erro que o código C++ pode converter em exceções, se necessário.
• Chamadas de retorno (callbacks). Se as funções C usam callbacks em C++, esses callbacks devem capturar quaisquer exceções de C++ internamente, para que a exceção não saia ao exterior através do código C.
• Uso de noexcept. C++11 permite marcar explicitamente funções como noexcept, o que pode ser importante ao chamar funções C ou funções com extern "C", garantindo que essas funções não lancem exceções.

Exemplo que demonstra o problema de sobreposição de fronteiras:

#include <cstdio>
#include <stdexcept>

// Função C, declarada com extern "C"
extern "C" {
void c_function(int value) {
    if (value < 0) {
        // Não se pode lançar exceção através da fronteira C!
        // throw std::runtime_error("Valor negativo não permitido em C.");
        // Em vez disso, em C normalmente retornam um código de erro ou usam stderr
        fprintf(stderr, "Erro: Valor negativo não permitido em C.\n");
    }
    // ... resto da lógica da função C ...
}

// Função C++ que chama a função C
void cpp_function() {
    try {
        // Chamada à função C
        c_function(10);
        c_function(-5); // Esta chamada pode levar a um erro na função C
    } catch (const std::exception& e) {
        // Este bloco catch não será acionado se a função C lançar exceção através de extern "C"
        printf("Exceção capturada em C++: %s\n", e.what());
    }
}
}