Warum brauchen wir extern "C"{ #include <foo.h> } in C++?

C und C++ sind oberflächlich ähnlich, aber jede kompiliert in einen ganz anderen Satz von code. Wenn Sie eine header-Datei mit einem C++ - compiler der compiler rechnet C++ - code. Wenn, jedoch, es ist ein C header, dann der compiler erwartet die Daten in der header-Datei kompiliert werden, um einem bestimmten format—C++ "ABI", oder "Application Binary Interface", also der linker drosseln bis. Dies ist besser zu übergeben C++ Daten auf eine Funktion erwartet der C-Daten.

(Um in die wirklich nitty-gritty C++'s ABI im Allgemeinen 'mangles' die Namen der Funktionen/Methoden, so ruft printf() ohne Kennzeichnen den Prototyp einer C-Funktion, die C++ tatsächlich generieren Sie code aufrufen _Zprintf, plus extra Mist am Ende.)

Also: verwenden Sie extern "C" {...} beim einbinden einer c-header—so einfach ist das. Ansonsten haben Sie einen Konflikt in kompilierter code, und der linker ersticken. Für die meisten Header, jedoch, Sie brauchen nicht einmal die extern weil die meisten system C-Header bereits die Tatsache, dass Sie aufgenommen werden könnten, die von der C++ - code und schon extern Ihren code.

In C++ können Sie unterschiedliche Entitäten, die Freigabe einen Namen. Zum Beispiel hier ist eine Liste von Funktionen, die alle den Namen foo:

• A::foo()
• B::foo()
• C::foo(int)
• C::foo(std::string)

Um zwischen Ihnen zu unterscheiden alle, die C++ - compiler erstellen Sie eindeutige Namen für jede in einen Prozess, der als name-mangling oder dekorieren. C-Compiler das nicht zu tun. Darüber hinaus werden bei jedem C++ - compiler können dies tun, ist eine andere Art und Weise.

extern "C" sagt der C++ - compiler nicht ausführen, name-mangling auf den code innerhalb der geschweiften Klammern. Dies ermöglicht Ihnen das aufrufen von C-Funktionen aus C++.

Wann sollte man es verwenden?

Beim verknüpfen C libaries in C++ - Objekt-Dateien

Was passiert an der
compiler - /linker-Ebene, der von uns verlangt
um es zu nutzen?

C und C++ verwenden verschiedene Systeme für ein symbol zu benennen. Dies teilt dem linker mit dem C-Schema bei der Verknüpfung in der angegebenen Bibliothek.

Wie in Bezug auf die Kompilierung/Verlinkung
tut dies die Probleme lösen, die
das von uns verlangen, es zu benutzen?

Verwendung der C-Namensschema ermöglicht Ihnen die Referenz C-Stil-Symbole. Ansonsten hat der linker versuchen würde C++-style-Symbole, die nicht funktionieren würde.

Sollten Sie die Verwendung von extern "C" jederzeit, dass Sie einen header definieren von Funktionen, die Ihren Wohnsitz in eine Datei kompiliert, die von einem C-compiler, verwendet in einer C++ - Datei. (Viele standard-C-Bibliotheken umfassen kann diese Prüfung in Ihrem Header zu machen es einfacher für die Entwickler)

Zum Beispiel, wenn Sie ein Projekt mit 3 Dateien, util.c, util.h, und main.cpp und sowohl die .c und .cpp-Dateien sind kompilierte C++ - compiler (g++, cc, etc) dann ist es nicht wirklich nötig, und kann sogar dazu führen, linker Fehler. Wenn Ihr build-Prozess verwendet eine normale C-compiler für util.c, dann müssen Sie die Verwendung von extern "C", wenn darunter util.h.

Was passiert ist, dass C++ kodiert die Parameter der Funktion in seinem Namen. Dies ist, wie das überladen von Funktionen arbeitet. Alle, die dazu neigt zu geschehen, um eine C-Funktion ist die Zugabe von einem Unterstrich ("_") an den Anfang des namens. Ohne Verwendung von extern "C" wird der linker auf der Suche nach einer Funktion mit dem Namen DoSomething@@int@float (), wenn die Funktion der eigentliche name ist _DoSomething() oder nur DoSomething().

Verwendung von extern "C" löst das obige problem, indem er dem C++ - compiler, der sollte sich für eine Funktion folgt, dass die C-Namenskonvention anstatt C++ ein.

Den extern "C" {} Konstrukt weist den compiler nicht ausführen mangeln auf Namen deklariert, die innerhalb der geschweiften Klammern. Normalerweise ist der C++ - compiler "verbessert die Funktion" Namen, so dass Sie Kodieren, geben Sie Informationen über die Argumente und den Rückgabewert; das ist rief der entstellten Namen. Die extern "C" - Konstrukt verhindert, dass die mangeln.

Es ist in der Regel verwendet, wenn C++ - code aufrufen muss, eine C-Sprache-Bibliothek. Es kann auch verwendet werden, wenn Sie eine C++ - Funktion (aus einer DLL zum Beispiel) bis C-Kunden.

Dekompilieren einer g++ erzeugten Binär-zu sehen, was Los ist

Bewege ich mich in dieser Antwort von: Was ist die Wirkung von extern "C" in C++? denn diese Frage wurde als Duplikat von diesem.

main.cpp

void f() {}
void g();

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

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

Kompilieren mit GCC 4.8 Linux ELF Ausgabe:

g++ -c main.cpp

Dekompilieren der symbol-Tabelle:

readelf -s main.o

Die Ausgabe enthält:

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

Interpretation

Sehen wir, dass:

• ef und eg gespeichert wurden, in Symbole mit dem gleichen Namen wie im code

• die anderen Symbole wurden entstellt. Lassen Sie uns unmangle Sie:

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

Fazit: beide der folgenden symbol-Typen wurden nicht entstellt:

• definiert
• deklariert, aber nicht definiert (Ndx = UND), zur Verfügung gestellt werden, die zur link-oder zur Zeit von einem anderen Objekt-Datei

So müssen Sie extern "C" sowohl beim Aufruf:

• C von C++: sagen g++ zu erwarten unmangled Symbole produziert von gcc
• C++ von C: sagen Sie g++ zu generieren unmangled Symbole für gcc zu verwenden

Dinge, die nicht funktionieren in extern C

Wird es offensichtlich, dass jede C++ - Funktion, die erfordert, dass die name manglings funktioniert nicht innerhalb 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) { }
}

Minimaler ausführbarer C von C++ Beispiel

Der Vollständigkeit halber und für die newbs gibt, siehe auch: Wie der Einsatz von C-source-Dateien in ein C++ - Projekt?

Aufrufen von C von C++ ist ziemlich einfach: jede C-Funktion hat nur eine mögliche, nicht entstellten symbol, so dass keine zusätzliche Arbeit erforderlich ist.

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

c.c

#include "c.h"

int f(void) { return 1; }

Run:

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

Ohne extern "C" den link nicht mit:

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

weil g++ erwartet, finden Sie eine entstellte f, die gcc nicht produzieren.

Beispiel auf GitHub.

Minimal lauffähigen C++ von C Beispiel

Aufrufen von C++ aus ist das ein bisschen schwieriger: wir haben manuell zu erstellen, nicht entstellten Versionen von jeder Funktion, die wir wollen, zu entlarven.

Hier zeigen wir, wie zu setzen C++ - Funktion überlastungen zu 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);
}

Run:

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

Ohne extern "C" schlägt es mit:

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

weil g++ generiert entstellte Symbole, die gcc nicht finden können.

Beispiel auf GitHub.

Getestet in Ubuntu 18.04.