What should be considered when interacting between C…

When interacting between C and C++ in the context of exception handling, the following should be considered:

Crossing language boundaries. C++ exceptions cannot cross function boundaries with extern "C" linkage. This leads to undefined behavior.
Incompatibility of mechanisms. C does not have a built-in exception handling mechanism (like try-catch in C++), relying instead on error codes or setjmp/longjmp.
Exception safety. C++ code calling C functions should be aware that these C functions may not be exception safe. They do not invoke destructors of local C++ objects when exiting via longjmp.
Exception catching. C++ try-catch blocks should be used to handle C++ exceptions before calling C functions or after returning from them.
Error state transfer. C functions should return error codes that C++ code can then convert into exceptions if necessary.
Callbacks. If C functions use C++ callbacks, these callbacks should catch any C++ exceptions internally to prevent exceptions from escaping through C code.
Use of noexcept. C++11 allows explicitly marking functions as noexcept, which can be important when calling C functions or functions with extern "C", ensuring these functions do not throw exceptions.

An example demonstrating the crossing boundary problem:

#include <cstdio>
#include <stdexcept>

// C function declared with extern "C"
extern "C" {
void c_function(int value) {
    if (value < 0) {
        // Cannot throw an exception across C boundary!
        // throw std::runtime_error("Negative value is not allowed in C.");
        // Instead, C typically returns an error code or uses stderr
        fprintf(stderr, "Error: Negative value is not allowed in C.\n");
    }
    // ... rest of the C function logic ...
}

// C++ function calling C function
void cpp_function() {
    try {
        // Call C function
        c_function(10);
        c_function(-5); // This call may lead to an error in the C function
    } catch (const std::exception& e) {
        // This catch block will not trigger if the C function throws an exception through extern "C"
        printf("Caught exception in C++: %s\n", e.what());
    }
}
}

What should be considered when interacting between C and C++ in the context of exception handling?