Function Prototypes and Headers in C++

Most real programs are built from several pieces, such as separate source files and libraries. Each piece may call functions that are defined somewhere else. Something has to connect every call in one piece to the function definition in another piece. That connection is governed by linkage, which describes how functions and variables are accessed across different source files and libraries.

When a program is built from several pieces, the linker has to connect each call to the function defined elsewhere. Whether two pieces of code connect smoothly depends on the linkage conventions the languages use. This is why linkage needs special attention as soon as C and C++ code are mixed in one program.

C and C++ can be implemented to use different linkage conventions, and often are. The most basic reason is C++'s greater emphasis on type checking. A practical reason is that C++ supports overloading, which lets a program contain two global functions with the same name, such as two functions both called open(). C does not allow this, so the linker has to be able to tell these cases apart in a way that reflects each language's rules.

Think of the linker as a matcher. It receives pieces of compiled code, and for each call it looks for the definition that the call refers to. A call in a C fragment and a call in a C++ fragment can both target the same function, such as the square-root function that takes and returns a double. The declaration is the point where the two languages agree on how that function is linked.

The diagram shows the role of the declaration. Once the declaration is in place, sqrt(double) can be called from either a C or a C++ code fragment. The definition of sqrt(double) can also be compiled either as a C function or as a C++ function. The linker can then connect both kinds of call to that one definition, because the declaration fixed the linkage both sides rely on.

To call a C function from a C++ program fragment, declare it with extern "C". The same declaration form also gives a C++ function C linkage, so that it can be called from a C program fragment. Each part of the declaration has a separate job, as the anatomy below shows.

Read left to right, the declaration first says that the function has C linkage, which is the part that controls how it is linked. The return type double, the name sqrt, and the parameter list (double) then describe the function itself. The linkage part and the signature part are separate. Changing the linkage convention does not by itself change what arguments the function accepts or what it returns.

A linkage specification changes how a function is linked. It does not change how the function is checked. The C++ rules for function calls and argument checking still apply to a function declared with extern "C". This is the most common misunderstanding about the feature, so it is worth testing your own expectation before reading the answer.

The difference between the two languages becomes clearer when the same function name is considered under each set of rules. In C, a given name can refer to only one global function of that name in a scope. In C++, overloading allows several global functions to share a name, so the linker must account for more than the name alone when it matches a call to a definition.

This is why a C-linkage function is restricted. Only one function of a given name in a scope can have C linkage, because C does not allow overloading. If a C++ program contains two overloads with the same name, such as two functions both called open(), they cannot both be given C linkage in that scope. The overloads still exist in C++, but the C linkage rule cannot match two same-named functions under C's one-name-per-function convention.