How does an extern "C" declaration work?

Question

I'm taking a programming languages course and we're talking about the extern "C" declaration.

How does this declaration work at a deeper level other than "it interfaces C and C++"? How does this affect the bindings that take place in the program as well?

Spevek

Answer 1

extern "C" is used to ensure that the symbols following are not mangled (decorated).

---

Example:

Let's say we have the following code in a file called test.cpp:

extern "C" {
  int foo() {
    return 1;
  }
}

int bar() {
  return 1;
}

If you run gcc -c test.cpp -o test.o

Take a look at the symbols names:

00000010 T _Z3barv

00000000 T foo

foo() keeps its name.

Desegregate

Also that functions use the C calling convention, if it differs from the C++ calling convention. Which it probably doesn't, for C++ functions which take only types from C as parameters, but with extern "C" it definitely doesn't. – Descendible

What call did you use to get the symbol names there? – Kristeenkristel

Answer 2

Let's look at a typical function that can compile in both C and C++:

int Add (int a, int b)
{
    return a+b;
}

Now in C the function is called "_Add" internally. Whereas the C++ function is called something completely different internally using a system called name-mangling. Its basically a way to name a function so that the same function with different parameters has a different internal name.

So if Add() is defined in add.c, and you have the prototype in add.h you will get a problem if you try to include add.h in a C++ file. Because the C++ code is looking for a function with a name different to the one in add.c you will get a linker error. To get around that problem you must include add.c by this method:

extern "C"
{
#include "add.h"
}

Now the C++ code will link with _Add instead of the C++ name mangled version.

That's one of the uses of the expression. Bottom line, if you need to compile code that is strictly C in a C++ program (via an include statement or some other means) you need to wrap it with a extern "C" { ... } declaration.

Colombes

The leading _ is compiler/linker/system dependent. – Cockboat

Ok, but I've never come across a C compiler that doesn't do that, even from the Amiga days :) – Colombes

this answer helps in resolving linker errors saying unresolved external symbols while other answers give some detailed concept. – Missy

Answer 3

When you flag a block of code with extern "C", you're telling the system to use C style linkage.

This, mainly, affects the way the linker mangles the names. Instead of using C++ style name mangling (which is more complex to support operator overloads), you get the standard C-style naming out of the linker.

Insolvency

I don't think you should be suggesting that a method could be flagged with extern "C". Single functions or multiple functions are OK. – Derk

@Reed: err.. I've just realised that you talk of linkage and linkers. It affects the compiler naming, which only indirectly affects the linker. – Derk

@quamrana: Read msdn.microsoft.com/en-us/library/0603949d(VS.80).aspx - It does directly affect, and is used by, the linker. The compiler mangles the name, but the linker is the one that USES the naming - extern "C" is there in order to allow the linker to work properly, whether in C or C++, since the linker is the one that has to determine how to map between translation units. – Insolvency

Answer 4

It should be noted that extern "C" also modifies the types of functions. It does not only modify things on lower levels:

extern "C" typedef void (*function_ptr_t)();

void foo();

int main() { function_ptr_t fptr = &foo; } // error!

The type of &foo does not equal the type that the typedef designates (although the code is accepted by some, but not all compilers).

Brutus

Answer 5

In C++ the name/symbol of the functions are actually renamed to something else such that different classes/namespaces can have functions of same signatures. In C, the functions are all globally defined and no such customized renaming process is needed.

To make C++ and C talk with each other, "extern C" instructs the compiler not to use the C convention.

Dur

for more on name mangling, there's Wikipedia: en.wikipedia.org/wiki/Name_mangling – Overpass

' "extern C" instructs the compiler not to use the C convention' No that's backwards. "extern C" instructs a C++ compiler TO use the C convention for naming symbols. – Caucasoid

Answer 6

extern C affects name mangling by the C++ compiler. Its a way of getting the C++ compiler to not mangle names, or rather to mangle them in the same way that a C compiler would. This is the way it interfaces C and C++.

As an example:

extern "C" void foo(int i);

will allow the function to be implemented in a C module, but allow it to be called from a C++ module.

The trouble comes when trying to get a C module to call a C++ function (obviously C can't use C++ classes) defined in a C++ module. The C compiler doesn't like extern "C".

So you need to use this:

#ifdef __cplusplus
extern "C" {
#endif

void foo(int i);

#ifdef __cplusplus
}
#endif

Now when this appears in a header file, both the C and C++ compilers will be happy with the declaration and it could now be defined in either a C or C++ module, and can be called by both C and C++ code.

Derk

Answer 7

extern "C" denotes that the enclosed code uses C-style linking and name mangling. C++ uses a more complex name mangling format. Here's an example:

http://en.wikipedia.org/wiki/Name_mangling

int example(int alpha, char beta);

in C: _example

in C++: __Z7exampleic

Update: As GManNickG notes in the comments, the pattern of name mangling is compiler dependent.

Labanna

Keep in mind there is no single name mangling, it's all dependent on implementation. – Contrarious

Answer 8

extern "C", is a keyword to declare a function with C bindings, because C compiler and C++ compiler will translate source into different form in object file:

For example, a code snippet is as follows:

int _cdecl func1(void) {return 0}
int _stdcall func2(int) {return 0}
int _fastcall func3(void) {return 1}

32-bit C compilers will translate the code in the form as follows:

_func1
_func2@4
@func3@4

in the cdecl, func1 will translate as '_name'

in the stdcall, func2 will translate as '_name@X'

in the fastcall, func2 will translate as '@name@X'

'X' means the how many bytes of the parameters in parameter list.

64-bit convention on Windows has no leading underscore

In C++, classes, templates, namespaces and operator overloading are introduced, since it is not allowed two functions with the same name, C++ compiler provide the type information in the symbol name,

for example, a code snippet is as follows:

int func(void) {return 1;}
int func(int) {return 0;}
int func_call(void) {int m=func(), n=func(0);}

C++ compiler will translate the code as follows:

int func_v(void) {return 1;}
int func_i(int) {return 0;}
int func_call(void) {int m=_func_v(), n=_func_i(0);}

'_v' and '_i' are type information of 'void' and 'int'

Tweezers

Answer 9

Here is a quote from msdn

"The extern keyword declares a variable or function and specifies that it has external linkage (its name is visible from files other than the one in which it's defined). When modifying a variable, extern specifies that the variable has static duration (it is allocated when the program begins and deallocated when the program ends). The variable or function may be defined in another source file, or later in the same file. Declarations of variables and functions at file scope are external by default."

http://msdn.microsoft.com/en-us/library/0603949d%28VS.80%29.aspx

Pasadis

It is a quote from Microsoft, And the way it has been used for years, You are going to ding me with a quote from Microsoft, I suggest you go take a c class – Pasadis

Right, Microsoft, those world-famous pioneers of easily-understandable documentation. That quote is technically correct, but useless to a beginner. – St

Being a "quote from Microsoft" doesn't make it relevant to the question at hand. It's talking about extern in other contexts. – Birth

It is much clearer than the above definitions for a beginner than introducing mangling to a beginner. If it is technical correct then why the ding??? – Pasadis

@Joe, because it's not an answer to the question. extern by itself and extern "C" do different things. – Cockboat

It says nothing about the "C" part. You can't explain extern "c" without mentioning mangling. – Birth

Actually I meant to ask for this. I misread the question of "extern in C" to be "extern C". – Spevek