it-swarm.com.ru

Каково влияние extern "C" в C ++?

Что именно делает помещение extern "C" в код C++?

Например:

extern "C" {
   void foo();
}
1409
Litherum

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

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

Точно так же, как вы знаете, вы можете явно указать связь "C" для каждого отдельного объявления/определения или использовать блок для группировки последовательности объявлений/определений, чтобы иметь определенную связь:

extern "C" void foo(int);
extern "C"
{
   void g(char);
   int i;
}

Если вы заботитесь о технических деталях, они перечислены в разделе 7.5 стандарта C++ 03, вот краткое резюме (с акцентом на extern "C"):

  • extern "C" является спецификацией связи
  • Каждый компилятор требуется для обеспечения связи "C"
  • спецификация связи должна встречаться только в области имен
  • все типы функций, имена функций и имена переменных имеют языковую связьсм. Комментарий Ричарда: Только имена функций и имена переменных с внешней связью имеют языковую связь
  • два типа функций с разными языковыми связями являются разными типами, даже если в противном случае они идентичны
  • гнездо спецификаций связи, внутреннее определяет окончательную связь
  • extern "C" игнорируется для членов класса
  • не более одной функции с конкретным именем может иметь связь "C" (независимо от пространства имен)
  • extern "C" заставляет функцию иметь внешнюю связь (не может сделать ее статической)См. Комментарий Ричарда: 'static' inside 'extern "C"' допустим; заявленная сущность имеет внутреннюю связь и поэтому не имеет языковой связи
  • Связь с C++ с объектами, определенными в других языках, и с объектами, определенными в C++ из других языков, определяется реализацией и зависит от языка. Только в тех случаях, когда стратегии размещения объектов двух языковых реализаций достаточно похожи, такая связь может быть достигнута
1389
Faisal Vali

Просто хотел добавить немного информации, так как я еще не видел ее опубликованной.

Вы очень часто будете видеть код в заголовках C, например:

#ifdef __cplusplus
extern "C" {
#endif

// all of your legacy C code here

#ifdef __cplusplus
}
#endif

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

Хотя я также видел код C++, такой как:

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

который я представляю, выполняет то же самое.

Не уверен, какой путь лучше, но я видел оба.

280
UncaAlby

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

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

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

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

Это удобно при использовании dlsym() и dlopen() для вызова таких функций.

195
sud03r

Декомпилируйте сгенерированный двоичный код g++, чтобы увидеть, что происходит

main.cpp

void f() {}
void g();

extern "C" {
    void ef() {}
    void eg();
}

/* Prevent g and eg from being optimized away. */
void h() { g(); eg(); }

Скомпилировать с GCC 4.8 Linux ELF вывод:

g++ -c main.cpp

Декомпилируйте таблицу символов:

readelf -s main.o

Вывод содержит:

Num:    Value          Size Type    Bind   Vis      Ndx Name
  8: 0000000000000000     6 FUNC    GLOBAL DEFAULT    1 _Z1fv
  9: 0000000000000006     6 FUNC    GLOBAL DEFAULT    1 ef
 10: 000000000000000c    16 FUNC    GLOBAL DEFAULT    1 _Z1hv
 11: 0000000000000000     0 NOTYPE  GLOBAL DEFAULT  UND _Z1gv
 12: 0000000000000000     0 NOTYPE  GLOBAL DEFAULT  UND eg

Интерпретация

Мы видим, что:

  • ef и eg хранились в символах с тем же именем, что и в коде

  • другие символы были искажены. Давайте разобьем их:

    $ c++filt _Z1fv
    f()
    $ c++filt _Z1hv
    h()
    $ c++filt _Z1gv
    g()
    

Вывод: оба следующих типа символов были не искалечены:

  • определенный
  • объявлено, но не определено (Ndx = UND), будет предоставлено по ссылке или во время выполнения из другого объектного файла

Таким образом, вам потребуется extern "C" при вызове:

  • C из C++: скажите g++ ожидать, что не исправленные символы будут созданы gcc
  • C++ из C: скажите g++ генерировать не исправленные символы для использования gcc

Вещи, которые не работают во внешнем C

Становится очевидным, что любая функция C++, требующая искажения имени, не будет работать внутри extern C:

extern "C" {
    // Overloading.
    // error: declaration of C function ‘void f(int)’ conflicts with
    void f();
    void f(int i);

    // Templates.
    // error: template with C linkage
    template <class C> void f(C i) { }
}

Пример минимального запуска C из C++

Для полноты картины и для новичков см. Также: Как использовать исходные файлы C в проекте C++?

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

main.cpp

#include <cassert>

#include "c.h"

int main() {
    assert(f() == 1);
}

c.h

#ifndef C_H
#define C_H

/* This ifdef allows the header to be used from both C and C++. */
#ifdef __cplusplus
extern "C" {
#endif
int f();
#ifdef __cplusplus
}
#endif

#endif

к.ц

#include "c.h"

int f(void) { return 1; }

Бежать:

g++ -c -o main.o -std=c++98 main.cpp
gcc -c -o c.o -std=c89 c.c
g++ -o main.out main.o c.o
./main.out

Без extern "C" ссылка завершается с:

main.cpp:6: undefined reference to `f()'

потому что g++ ожидает найти искаженное f, которое gcc не произвело.

Пример на GitHub .

Пример минимального запуска C++ из примера C

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

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

main.c

#include <assert.h>

#include "cpp.h"

int main(void) {
    assert(f_int(1) == 2);
    assert(f_float(1.0) == 3);
    return 0;
}

cpp.h

#ifndef CPP_H
#define CPP_H

#ifdef __cplusplus
// C cannot see these overloaded prototypes, or else it would get confused.
int f(int i);
int f(float i);
extern "C" {
#endif
int f_int(int i);
int f_float(float i);
#ifdef __cplusplus
}
#endif

#endif

cpp.cpp

#include "cpp.h"

int f(int i) {
    return i + 1;
}

int f(float i) {
    return i + 2;
}

int f_int(int i) {
    return f(i);
}

int f_float(float i) {
    return f(i);
}

Бежать:

gcc -c -o main.o -std=c89 -Wextra main.c
g++ -c -o cpp.o -std=c++98 cpp.cpp
g++ -o main.out main.o cpp.o
./main.out

Без extern "C" происходит сбой с:

main.c:6: undefined reference to `f_int'
main.c:7: undefined reference to `f_float'

потому что g++ генерирует искаженные символы, которые gcc не может найти.

Пример на GitHub .

Проверено в Ubuntu 18.04.

C++ искажает имена функций для создания объектно-ориентированного языка из процедурного языка

Большинство языков программирования не построены поверх существующих языков программирования. C++ построен поверх C, и, кроме того, это объектно-ориентированный язык программирования, построенный из процедурного языка программирования, и по этой причине существуют выражения C++, такие как extern "C", которые обеспечивают обратную совместимость с C.

Давайте посмотрим на следующий пример:

#include <stdio.h>

// Two functions are defined with the same name
// but have different parameters

void printMe(int a) {
  printf("int: %i\n", a);
}

void printMe(char a) {
  printf("char: %c\n", a);
}

int main() {
  printMe("a");
  printMe(1);
  return 0;
}

Компилятор C не будет компилировать приведенный выше пример, поскольку одна и та же функция printMe определяется дважды (даже если они имеют разные параметры int a vs char a).

gcc -o printMe printMe.c && ./printMe;
1 ошибка. PrintMe определяется более одного раза.

Компилятор C++ скомпилирует приведенный выше пример. Неважно, что printMe определяется дважды.

g ++ -o printMe printMe.c && ./printMe;

Это связано с тем, что компилятор C++ неявно переименовывает ( mangles ) функции в зависимости от их параметров. В C эта функция не поддерживалась. Однако, когда C++ был построен поверх C, язык был разработан, чтобы быть объектно-ориентированным, и должен был поддерживать возможность создавать различные классы с методами (функциями) с одинаковыми именами и переопределять методы ( переопределение методов) ) на основе разных параметров.

extern "C" говорит "не искажать имена функций C"

Однако представьте, что у нас есть устаревший C-файл с именем "parent.c", который includes называет имена функций из других унаследованных C-файлов, "parent.h", "child.h" и т.д. Если старый файл "parent.c" запущен через компилятор C++ имена функций будут искажены, и они больше не будут совпадать с именами функций, указанными в "parent.h", "child.h" и т. д., поэтому имена функций в этих внешних файлах также должны будут быть искалеченным. Переназначение имен функций в сложной программе на C, имеющих много зависимостей, может привести к поломке кода; поэтому может быть удобно предоставить ключевое слово, которое может сказать компилятору C++ не искажать имя функции.

Ключевое слово extern "C" говорит компилятору C++ не искажать (переименовывать) имена функций C. Пример использования: extern "C" void printMe(int a);

39
tfmontague

Он изменяет связь функции таким образом, что функция вызывается из C. На практике это означает, что имя функции не искалечено .

27
Employed Russian

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

Например, я видел следующий сбой кода в g ++:

extern "C" {
struct method {
    int virtual;
};
}

Kinda имеет смысл, но есть что-то, что следует иметь в виду при переносе C-кода на C++.

25
Sander Mertens

Он информирует компилятор C++ для поиска имен этих функций в стиле C при компоновке, потому что имена функций, скомпилированных в C и C++, различаются на этапе компоновки.

19
Mark Rushakoff

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

12
Flami

Ранее я использовал extern "C" для файлов dll (динамически подключаемых библиотек), чтобы сделать функцию main () и т.д. "Экспортируемой", чтобы позже ее можно было использовать в другом исполняемом файле из dll. Может быть, пример того, где я использовал его, может быть полезным.

DLL

#include <string.h>
#include <windows.h>

using namespace std;

#define DLL extern "C" __declspec(dllexport)
//I defined DLL for dllexport function
DLL main ()
{
    MessageBox(NULL,"Hi from DLL","DLL",MB_OK);
}

EXE

#include <string.h>
#include <windows.h>

using namespace std;

typedef LPVOID (WINAPI*Function)();//make a placeholder for function from dll
Function mainDLLFunc;//make a variable for function placeholder

int main()
{
    char winDir[MAX_PATH];//will hold path of above dll
    GetCurrentDirectory(sizeof(winDir),winDir);//dll is in same dir as exe
    strcat(winDir,"\\exmple.dll");//concentrate dll name with path
    HINSTANCE DLL = LoadLibrary(winDir);//load example dll
    if(DLL==NULL)
    {
        FreeLibrary((HMODULE)DLL);//if load fails exit
        return 0;
    }
    mainDLLFunc=(Function)GetProcAddress((HMODULE)DLL, "main");
    //defined variable is used to assign a function from dll
    //GetProcAddress is used to locate function with pre defined extern name "DLL"
    //and matcing function name
    if(mainDLLFunc==NULL)
    {
        FreeLibrary((HMODULE)DLL);//if it fails exit
        return 0;
    }
    mainDLLFunc();//run exported function 
    FreeLibrary((HMODULE)DLL);
}
6
SturmCoder

extern "C" - это спецификация связи, которая используется для вызова функций C в исходные файлы Cpp. Мы можем вызывать функции C, писать переменные и включать заголовки. Функция объявлена ​​во внешнем объекте и определена снаружи. Синтаксис

Тип 1:

extern "language" function-prototype

Тип 2:

extern "language"
{
     function-prototype
};

например:

#include<iostream>
using namespace std;

extern "C"
{
     #include<stdio.h>    // Include C Header
     int n;               // Declare a Variable
     void func(int,int);  // Declare a function (function prototype)
}

int main()
{
    func(int a, int b);   // Calling function . . .
    return 0;
}

// Function definition . . .
void func(int m, int n)
{
    //
    //
}
5
Yogeesh H T

Этот ответ для нетерпеливых/имевших сроки, только часть/простое объяснение ниже:

  • в C++ вы можете иметь одно и то же имя в классе через перегрузку (например, поскольку все они с одинаковым именем не могут быть экспортированы как есть из dll и т. д.), решение этих проблем заключается в том, что они преобразуются в разные строки (называемые символами ) символы учитывают имя функции, а также аргументы, поэтому каждая из этих функций, даже с одним и тем же именем, может быть однозначно идентифицирована (также называется, искажение имени)
  • в C у вас нет перегрузки, имя функции уникально (поэтому отдельная строка для уникального определения имени функции не требуется, поэтому символ является самим именем функции)

Так
в C++, с изменением имени уникально идентифицирует каждую функцию
в C, даже без искажения имени уникально идентифицирует каждую функцию

Чтобы изменить поведение C++, то есть указать, что искажение имени не должно происходит для конкретной функции, вы можете использовать extern "C" перед именем функции, для по любой причине, например, экспорт функции с определенным именем из DLL для использования ее клиентами.

Читайте другие ответы, для более подробных/более правильных ответов.

2
Manohar Reddy Poreddy

При смешивании C и C++ (т.е. вызов функции C из C++ и вызов функции C++ из C), искажение имен C++ вызывает проблемы с линковкой. Технически говоря, эта проблема возникает, только когда функции вызываемого абонента уже скомпилированы в двоичный файл (скорее всего, файл библиотеки * .a) с использованием соответствующего компилятора.

Поэтому нам нужно использовать extern "C", чтобы отключить искажение имени в C++.

1
Trombe