Как работает объявление extern C?

extern "C" используется для того, чтобы следующие символы не были искажены (украшены).

Пример:

Допустим, у нас есть следующий код в файле с именем test.cpp:

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

int bar() {
  return 1;
}

Если вы запустите gcc -c test.cpp -o test.o

Взгляните на названия символов:

00000010 Т _Z3barv

00000000 T foo

foo() сохраняет свое название.

Давайте посмотрим на типичную функцию, которая может компилироваться как в C, так и в C++:

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

Теперь в C функция называется "_Add" внутри. Принимая во внимание, что функция C++ вызывается совершенно по-другому внутри, используя систему, называемую искажением имен. По сути, это способ назвать функцию, чтобы одна и та же функция с разными параметрами имела другое внутреннее имя.

Поэтому, если Add() определен в add.c, а у вас есть прототип в add.h, вы столкнетесь с проблемой, если попытаетесь включить add.h в файл C++. Поскольку код C++ ищет функцию с именем, отличным от имени в add.c, вы получите ошибку компоновщика. Чтобы обойти эту проблему, вы должны включить add.c следующим образом:

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

Теперь код C++ будет связываться с _Add вместо измененной версии имени C++.

Это одно из применений выражения. Суть в том, что если вам нужно скомпилировать код, который является строго C в программе C++ (через оператор include или каким-либо другим способом), вам нужно обернуть его объявлением extern "C" { ... }.

Когда вы помечаете блок кода с помощью extern "C", вы указываете системе использовать компоновку в стиле C.

В основном это влияет на то, как компоновщик искажает имена. Вместо того, чтобы использовать изменение имен в стиле C++ (что более сложно для поддержки перегрузок операторов), вы получаете стандартное именование в стиле C из компоновщика.

Следует отметить, что extern "C" также изменяет типы функций. Он не только изменяет вещи на более низких уровнях:

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

void foo();

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

Тип &foo не равен типу, указанному в typedef (хотя код принимается некоторыми, но не всеми компиляторами).

В С++ имя/символ функций фактически переименовывается во что-то другое, так что разные классы/пространства имен могут иметь функции с одинаковыми сигнатурами. В языке C все функции определены глобально, и такой индивидуальный процесс переименования не требуется.

Чтобы заставить C++ и C взаимодействовать друг с другом, «extern C» указывает компилятору не использовать соглашение C.

extern C влияет на изменение имени компилятором C++. Это способ заставить компилятор C++ не искажать имена, а скорее искажать их так же, как компилятор C. Так он взаимодействует с C и C++.

Например:

extern "C" void foo(int i);

позволит реализовать функцию в модуле C, но позволит вызывать ее из модуля C++.

Проблема возникает при попытке заставить модуль C вызывать функцию C++ (очевидно, C не может использовать классы C++), определенную в модуле C++. Компилятор C не любит extern "C".

Итак, вам нужно использовать это:

#ifdef __cplusplus
extern "C" {
#endif

void foo(int i);

#ifdef __cplusplus
}
#endif

Теперь, когда это появляется в заголовочном файле, компиляторы C и C++ будут довольны объявлением, и теперь оно может быть определено либо в модуле C, либо в модуле C++, и может вызываться кодом как C, так и C++.

extern "C" означает, что во вложенном коде используется связывание в стиле C и изменение имени. C++ использует более сложный формат изменения имени. Вот пример:

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

int example(int alpha, char beta);

in C: _example

in C++: __Z7exampleic

Обновление: как отмечает GManNickG в комментариях, шаблон изменения имени зависит от компилятора.

extern "C" — это ключевое слово для объявления функции с привязками C, потому что компилятор C и компилятор C++ преобразуют исходный код в другую форму в объектном файле:

Например, фрагмент кода выглядит следующим образом:

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

32-битные компиляторы C преобразуют код в следующий вид:

_func1
_func2@4
@func3@4

в cdecl функция func1 будет переведена как '_name'

в стандартном вызове func2 будет переведено как '_name@X'

в быстром вызове func2 будет переведено как '@name@X'

'X' означает количество байтов параметров в списке параметров.

64-битное соглашение в Windows не имеет начального подчеркивания

В C++ введены классы, шаблоны, пространства имен и перегрузка операторов, поскольку не допускается наличие двух функций с одинаковыми именами, компилятор C++ предоставляет информацию о типе в имени символа,

например, фрагмент кода выглядит следующим образом:

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

Компилятор C++ преобразует код следующим образом:

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' и '_i' - это информация о типах 'void' и 'int'

Вот цитата из msdn

«Ключевое слово extern объявляет переменную или функцию и указывает, что она имеет внешнюю связь (ее имя видно из файлов, отличных от того, в котором она определена). При изменении переменной extern указывает, что переменная имеет статическую продолжительность (она выделяется когда программа начинается и освобождается, когда программа завершается). Переменная или функция могут быть определены в другом исходном файле или позже в том же файле. Объявления переменных и функций в области файла по умолчанию являются внешними».

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