原文链接：http://www.geeksforgeeks.org/extern-c-in-c/
C++ supports function overloading, i.e., there can be more than one functions with same name and differences in parameters. How does C++ compiler distinguishes between different functions when it generates object code – it changes names by adding information about arguments. This technique of adding additional information to function names is called Name Mangling. C++ standard doesn’t specify any particular technique for name mangling, so different compilers may append different information to function names.
Consider following declarations of function f()
1 int f (void) { return 1; }
2 int f (int) { return 0; }
3 void g (void) { int i = f(), j = f(0); }
A C++ compiler may mangle above names to following (Source: Wiki)
1 int __f_v (void) { return 1; }
2 int __f_i (int) { return 0; }
3 void __g_v (void) { int i = __f_v(), j = __f_i(0); }
How to handle C symbols when linking from C++?
In C, names may not be mangled as C doesn’t support function overloading. So how to make sure that name of a symbol is not changed when we link a C code in C++. For example, see the following C++ program that uses printf() function of C.
1 // Save file as .cpp and use C++ compiler to compile it
2 int printf(const char *format,...);
3
4 int main()
5 {
6 printf("GeeksforGeeks");
7 return 0;
8 }
Output:
1 undefined reference to `printf(char const*, ...)‘ ld returned 1 exit status
The reason for compiler error is simple, name of printf is changed by C++ compiler and it doesn’t find definition of the function with new name.
The solution of problem is extern “C” in C++. When some code is put in extern “C” block, the C++ compiler ensures that the function names are unmangled – that the compiler emits a binary file with their names unchanged, as a C compiler would do.
If we change the above program to following, the program works fine and prints “GeeksforGeeks” on console.
1 // Save file as .cpp and use C++ compiler to compile it
2 extern "C"
3 {
4 int printf(const char *format,...);
5 }
6
7 int main()
8 {
9 printf("GeeksforGeeks");
10 return 0;
11 }
Output:
1 GeeksforGeeks
Therefore, all C style header files (stdio.h, string.h, .. etc) have their declarations in extern “C” block.
1 #ifdef __cplusplus
2 extern "C" {
3 #endif
4 /* Declarations of this file */
5 #ifdef __cplusplus
6 }
7 #endif
Following are main points discussed above
1. Since C++ supports function overloading, additional information has to be added to function names (called name mangling) to avoid conflicts in binary code.
2. Function names may not be changed in C as C doesn’t support function overloading. To avoid linking problems, C++ supports extern “C” block. C++ compiler makes sure that names inside extern “C” block are not changed.