Introduction to Intermixing C and C++

When and why to use C linkage

While porting such applications, if developers have to intermix C and C++ code, they then have to depend on C++ language features like extern "C" for giving C linkage to some set of APIs. This is required because C and C++ compilers handle function prototype in a different way. C++ compilers use name mangling, (or name decoration) to generate unique names for identifiers in a program. It is because of this technique, in C++, that it is possible to overload any functions (this requires that all the overloaded functions should have a different argument list). The C++ mangled name for any identifier contains all the necessary information that may be needed by the linker, such as linkage type, scope, calling convention, and others.

All identifiers (function names or variable names) declared or defined in C++ source or headers are subject to name mangling. When it comes to C, however, there is nothing called name mangling or overloading. It applies when the developer tries to use C APIs by including corresponding headers. To avoid name mangling, the developer should mention explicitly that those APIs are C APIs, by using the extern "C" keyword.

Syntax of extern C

The syntax of extern "C" is shown below:

extern "C" declaration ;

The declaration (or definition) that immediately follows extern "C" has the C linkage.

extern "C" { 
   declaration ; 
   declaration ; 
   ... 
}

Everything between the curly braces has C linkage, unless declared otherwise.

How to use extern C

While writing header files with C functions which will be included by both C and C++ source files, the user must use extern "C" properly. See the example below:

/*File: GoodCHeader.h */
/* Can be used by C/C++ header and source files directly */

#ifdef __cplusplus
extern "C" {
#endif
/* Write C function declarations here */
void Function1(int, int);
char* Function3(char*, int);
int Function2(int);
#ifdef __cplusplus
} /* extern "C" */
#endif

Using ifdef __cplusplus is required since C does not support or recognize the extern keyword. It is C++ that provides the mechanisms for mixing C and C++ codes in the same program. To be precise, C++ supports mixing codes that are compiled by C and C++ compatible compilers in the same program.

If the C header is already defined and it does not have all the APIs defined under extern "C", then while including such a header in C++ source or header files, extern "C" should be used as in the example below:

*File: PureCHeader.h */
/* If C++ header/source files need to include this header, extern "C" should be used*/
/* Define all C APIs here*/
void Function1(int, int);
char* Function3(char*, int);
int Function2(int);
#endif


//File: CSource.cpp
// C++ source file using PureCHeader.h
extern "C" {
#include "PureCHeader.h"
}
void Foo() {
   // use those C APIs here
   int ret = Function2(10);
}

Mixing C and C++ features using extern "C"

The developer can use all the features of C++ except templates within C by giving those functions extern "C" linkage. See the example below:

#include <iostream>
using namespace std;

extern "C" {

//Can give C linkage to this class!!
class Sample{
public:
   Sample(int a = 10) : iMem(a) { }
   void Display() { cout<<"iMem is : "<<iMemend1; }
private:
   int iMem;
};

/*
//Can not  give C linkage to template!!
//If we uncomment this code, then it will give a compilation error.
template<class DataType> void Foo(DataType data) {
}*/
}

Extending C codes with C++ Codes

Using C linkage, C codes like structures and functions that manipulate those structures can be extended efficiently in a C++ source file as in the example below:

/* File: CHeader.h */
typedef struct{
   char* name;
   int id;
   float price;
} Item;

int Push(Item* item);
int Pop(Item* item);



/* File: CppHeader.h */
//Give external linkage to C structure
extern "C" {
# include "CHeader.h"
}

class MyStack : public Item {
public:
   MyStack(char* aName, int aId, float aPrice) : name(aName), id(aId), price(aPrice) { }
   int PushOnToStack() { return Push(this);}
   int PopFromStack() { return Pop(this); }
};