CERT C++: EXP56-CPP

The issue occurs when you call a function and provide a function type with a language linkage that does not match the language linkage of the function definition.

For instance, in this code snippet, the definition of function call_legacy_function_ptr() uses a function pointer legacy_fn_call with FORTRAN language linkage to interact with Fortran code. However, inside the function interact_with_legacy_code() the function call_legacy_function_ptr() is called with a function pointer fn_call with C++ language linkage, which is undefined behavior.

extern "FORTRAN" typedef void (*fortran_type)(int);
extern void call_legacy_function_ptr(fortran_type legacy_fn_call);
void fn_call(int); // fn_call has C++ language linkage

void interact_with_legacy_code()
{
   call_legacy_function_ptr(fn_call);
}

A function call that uses a function type with a language linkage that does not match the language linkage of the function definition is undefined behavior. Depending on your compiler implementation, the function call might result in runtime issues such as call stack corruption.

Note that some compilers accept code with mismatched language linkage without issuing a warning or error.

Do not use a function type with a language linkage that does not match the language linkage in the function definition, unless you determine that the mismatch has no effect on the runtime behavior of the program.

#include <iostream>

extern "C" typedef void (*C_type)(int);
void c_code_call(C_type C_func)
{
   std::cout << "Calling C code.\n";
   C_func;
   std::cout << "Returning to  C++ code\n";
}

void caller_func(int) // C++ language linkage
{
   std::cout << "Executing caller function.\n";
}

int main()
{
   c_code_call(caller_func); // Noncompliant
   return 0;
}

In this example, the function c_code_call expects a function with C language linkage as a parameter. However, when the function c_code_call is called inside of main() the call uses function caller_func with C++ language linkage. This mismatch is undefined behavior and might lead to runtime issues or crashes.

One Possible correction is to declare the function caller_func() with C language linkage to match the language linkage in the declaration of the function c_code_call.

#include <iostream>

extern "C" typedef void (*C_type)(int);
void c_code_call(C_type C_func)
{
   std::cout << "Calling C code.\n";
   C_func;
   std::cout << "Returning to  C++ code\n";
}

extern "C" void caller_func(int)
{
   std::cout << "Executing caller function.\n";
}

int main()
{
   c_code_call(caller_func); // Compliant
   return 0;
}