by: Jayson McleodPosted on

In the software development space, combining C and C++ programming elements is crucial. The keyword ‘extern C’ emerges as a core component, bridging the gap to facilitate seamless function calls from C to C++ and vice versa. 


We will delve into the intricate aspects of using ‘extern C’ to unravel its integral role in ensuring cross-language compatibility.

Unraveling ‘extern C’


‘Extern C’ is a linkage specifier employed in C and C++ to declare functions, objects, or code blocks linked with C. This specifier informs the compiler to apply C-compatible naming and calling conventions to the declared entities. In simpler terms, it aids in making C++ code accessible from C language, and vice versa.

The Significance of ‘extern C’

Let’s explore why this linkage specifier is crucial when working with functions and objects.

Name Mangling


C++ compilers often engage in a technique called “name mangling” to encode the names of functions and variables based on their parameters and types. This encoding supports function overloading and other C++ features. However, C compilers do not mangle names. With ‘extern C’, a C++ compiler can be instructed to employ C-style naming for a specific function, making it accessible from C code.

Cross-Language Compatibility


If you possess a C++ library or module that you desire to utilize in a C language project, ‘extern C’ enables the revelation of a C-compatible interface. Consequently, C code can invoke C++ functions without compatibility issues.

Dynamic Linking

In the creation of dynamic link libraries (DLLs) or shared libraries (SO files) in C++, unveiling some functions for usage in C language programs may be necessary. Declaring these functions with ‘extern C’ assures consistent and compatible function names across diverse languages.

Implementing ‘extern C’


To leverage ‘extern C’ effectively, the steps include:

  • Include Header Files: Incorporate a C++ header file containing the function declarations intended to be accessed from C code;
  • Employ Extern C: Encase the function declarations in an ‘extern “C”‘ block to designate a C linkage. For instance:
extern "C" {
    void myFunction(int arg);
    int addNumbers(int a, int b);
}
  • Compile with a C++ Compiler: Ensure the C++ code is compiled using a C++ compiler to enforce the extern C declarations.

The C code can then include the header file containing the extern C declarations and utilize the functions as if they were written in C.

Practical Example

Consider a C++ library containing a function for adding two numbers, and the need arises to access this function from a C program.

In the C++ header file (let’s call it mylib.h), declare the function using ‘extern “C”‘:

extern "C" {
    int addNumbers(int a, int b);
}

Implement the function in a C++ source file (mylib.cpp):

int addNumbers(int a, int b) {
    return a + b;
}

In the C code, include the mylib.h header file and call the ‘addNumbers’ function as a typical C function.

#include "mylib.h"
#include <stdio.h>

int main() {
    int sum = addNumbers(5, 7);
    printf("Sum: %d\n", sum);
    return 0;
}


Following these steps and utilizing ‘extern C’ facilitates effortless integration of C and C++ codes, opening avenues for code reuse and enhanced compatibility.

Conclusion

Extern C is an invaluable tool fostering seamless integration between C and C++ codebases. It simplifies the process of accessing C++ functions from C, proving indispensable in multi-language projects. 

Declaring functions and objects with ‘extern C’ enhances cross-language compatibility, promotes code reuse, and improves collaboration among C and C++ developers.

Leave a Reply