CODEWITHSUNDEEP
c++cg++gnu
Peter Toft
Peter Toft

Reputation: 707

Impact of using extern "C" { on C++ code when using g++

When using G++ (e.g. version 4.5 on Linux) can anyone explain what will/can happen if a user writes a header file for a mixed C/C++ system like this:

#ifdef __cplusplus 

extern "C" {

int myCPPfunc(some_arg_list....); /* a C++ function */

}
#endif

but here myCPPfunc() is a normal C++ function with a class def inside - i.e. it was wrongly labeled as a C function.

What is the impact of this?

Upvotes: 2

Views: 2925

Answers (4)

Michael Burr
Michael Burr

Reputation: 340168

This is exactly what extern "C" is for - it allows you to write a C++ function that can be called from C.

Essentially, that declaration is telling the C++ compiler that you want the C++ function myCPPfunc() to have an external interface that is linkable (and therefore callable) from C.

The implementation of the function is still C++ and can still use C++ features.

Typically, the declaration of the function in the header file might look more like:

#ifdef __cplusplus 
extern "C" {
#endif

int myCPPfunc(some_arg_list....); /* a C++ function */

#ifdef __cplusplus 
}
#endif

That lets the same header file be used by either the C++ compiler or the C compiler, and each will see it as declaring a C callable function.

Upvotes: 0

nate_weldon
nate_weldon

Reputation: 2349

This tells the C++ compiler that the functions declared in the header file are C functions.

http://www.parashift.com/c++-faq-lite/mixing-c-and-cpp.html#faq-32.2

Upvotes: 1

zwol
zwol

Reputation: 140445

It is perfectly legitimate to have the implementation of an extern "C" function use arbitrary C++ features. What you can't do is have its interface be something you couldn't do in C, e.g. argument overloading, methods (virtual or otherwise), templates, etc.

Be aware that a lot of the "something you couldn't do in C" cases provoke undefined behavior rather than prompt compile errors.

Upvotes: 1

Daniel
Daniel

Reputation: 31559

The main impact of this is that you cannot overload it, e.g. this is legal:

int myCPPfunc(int a);
int myCPPfunc(char a);

But this is not:

extern "C"
{
    int myCPPfunc(int a);
    int myCPPfunc(char a);
}

Upvotes: 1

Related Questions