Question

In a mixed C/C++ project, we need to make a call from C to a C++ function. The function to be called is overloaded as three separate functions, but we can ignore that from the C-side, we just pick the one most suitable and stick to that one.

There’s two ways to do this: (1) write a small C++ wrapper with a extern “C” function that forwards the call to the chosen overloaded function, or (2) the hackish way to just declare the one function we want to call from C as extern “C”.

The question is, is there any disadvantages (apart from nightmares and bad karma) to go for the second variant? In other words, given three overloaded function, where one is declared as exern “C”, should we expect trouble with the C++ side, or is this well defined according to the standard?

Answer 1

I believe the language in the standard is specifically written to allow exactly one function with “C” linkage, and an arbitrary number of other functions with “C++” linkage that overload the same name (§[dcl.link]/6):

At most one function with a particular name can have C language linkage. Two declarations for a function with C language linkage with the same function name (ignoring the namespace names that qualify it) that appear in different namespace scopes refer to the same function. Two declarations for an object with C language linkage with the same name (ignoring the namespace names that qualify it) that appear in different namespace scopes refer to the same object.

The standard shows the following example:

complex sqrt(complex); // C + + linkage by default
extern "C" {
    double sqrt(double); // C linkage
}