Memory Management When Converting from malloc and free to new and delete

When a C program is converted to C++, or when C and C++ code have to work together in one program, the two languages meet at the linker. The linker is the tool that connects a call made in one compiled piece of code to the function that is defined in another piece. Whether that connection works smoothly depends on the linkage conventions each language uses, and the two languages do not always use the same ones. This article explains why that is so and how the extern "C" declaration bridges the gap.

Think of a program built from two files. One file calls a function named sqrt, and a different file, or a library, contains the definition of sqrt. Nothing in the calling file contains the body of that function. The linker's job is to match the call with the definition. Linkage is the set of rules that makes that matching possible, so a call in one piece can find the right function in another.

C and C++ can be implemented to use different linkage conventions, and in practice they often are. The most basic reason is that C++ places a greater emphasis on type checking. A second, practical reason is that C++ supports overloading.

Overloading lets a program contain two global functions with the same name. The source's example is two functions that are both called open(). C does not allow this. Because C++ allows it, the linker has to be able to tell the two functions apart in a way that reflects the rules of the language. Since C has no such need, C linkage can treat a name more simply. This difference is why linkage needs special attention whenever C and C++ code are mixed.

To call a C function from a C++ program fragment, you declare it with extern "C". The same declaration form also gives a C++ function C linkage, so that the function can be called from a C program fragment. The source's standard example is the declaration of the square-root function, which takes a double and returns a double.

Reading the declaration from left to right: extern "C" is the part that changes the linkage. The double before the name is the return type, sqrt is the name, and the parentheses hold the parameter list. Everything after extern "C" is an ordinary function declaration. The linkage specification is added to the declaration; it does not replace the function's type information.

The difference between the two languages is easiest to see by comparing the same function name under each set of rules. Under C rules, one name refers to one global function in a scope, so the name alone is enough for the linker to find it. Under C++ rules, several overloads can share the name open, and the linker must distinguish them. The diagram below shows the two situations side by side. The exact internal naming scheme a C++ compiler uses is not described in the available material, so the diagram shows only the distinction itself.

A linkage specification changes how a function is linked. It does not change how the function is checked. This is the most important point to remember. A function declared with extern "C" still follows the C++ rules for function calls and argument checking, and it still takes part in overload resolution at the call site.

The pipeline shows the division of labor. Each compiler handles its own language, and the linker's task is to join the compiled pieces. The declaration with extern "C" in the C++ file is what tells that side of the program which linkage convention to expect for the C function, so the call and the definition can meet at the linker.