c++ - Qual è l'effetto di extern "C" in C ++?




6 Answers

Volevo solo aggiungere un po 'di informazioni, dato che non l'ho ancora visto pubblicato.

Vedrai molto spesso il codice in intestazioni C in questo modo:

#ifdef __cplusplus
extern "C" {
#endif

// all of your legacy C code here

#ifdef __cplusplus
}
#endif

Ciò che compie è che ti permette di usare quel file di intestazione C con il tuo codice C ++, perché verrà definita la macro "__cplusplus". Ma puoi anche usarlo con il tuo codice C legacy, dove la macro NON è definita, quindi non vedrà il costrutto C ++ in modo univoco.

Sebbene, ho anche visto il codice C ++ come:

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

che immagino compia più o meno la stessa cosa

Non sono sicuro quale sia la via migliore, ma ho visto entrambi.

c++ c linkage name-mangling extern-c

Che cosa fa esattamente la extern "C" in codice C ++?

Per esempio:

extern "C" {
   void foo();
}



Decompila un file binario generato da g++ per vedere cosa sta succedendo

Ingresso:

void f() {}
void g();

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

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

Compilare con l'output ELF di GCC 4.8 Linux:

g++ -c a.cpp

Decompila la tabella dei simboli:

readelf -s a.o

L'output contiene:

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

Interpretazione

Lo vediamo:

  • ef e eg sono stati memorizzati in simboli con lo stesso nome del codice

  • gli altri simboli sono stati mutilati. Mistriamoli:

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

Conclusione: entrambi i seguenti tipi di simboli non sono stati alterati:

  • definito
  • dichiarato ma non definito ( Ndx = UND ), da fornire al collegamento o tempo di esecuzione da un altro file oggetto

Quindi avrai bisogno di una extern "C" sia quando chiamerai:

  • C da C ++: indica a g++ di aspettarsi simboli non complicati prodotti da gcc
  • C ++ da C: tell g++ per generare simboli senza maglie per gcc da usare

Cose che non funzionano nell'esterno C

Diventa ovvio che qualsiasi funzionalità di C ++ che richiede un nome di manomissione non verrà eseguita all'interno di 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 minima eseguibile dall'esempio C ++

Per motivi di completezza e per i newbs là fuori.

Chiamare C da C ++ è piuttosto semplice: ogni funzione C ha solo un possibile simbolo non mutilato, quindi non è richiesto alcun lavoro extra.

main.cpp:

#include <cassert>

#include "c.h"

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

ch:

#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

cc:

#include "c.h"

int f(void) { return 1; }

Correre:

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

Senza extern "C" il link fallisce con:

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

perché g++ aspetta di trovare un f mangled, che gcc non ha prodotto.

Esempio su GitHub .

C ++ eseguibile minimo nell'esempio C.

Chiamare C ++ da è un po 'più difficile: dobbiamo creare manualmente versioni non mutilate di ogni funzione che vogliamo esporre.

Qui illustriamo come esporre gli overload di funzioni C ++ a 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);
}

Correre:

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

Senza extern "C" fallisce con:

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

perché g++ generato simboli storpiati che gcc non riesce a trovare.

Esempio su GitHub .




Cambia il collegamento di una funzione in modo tale che la funzione sia richiamabile da C. In pratica ciò significa che il nome della funzione non viene mangled .




Informa il compilatore C ++ per cercare i nomi di quelle funzioni in uno stile C durante il collegamento, perché i nomi delle funzioni compilate in C e C ++ sono diversi durante la fase di collegamento.




Ho usato "extern" C "prima per i file dll (dynamic link library) per rendere ecc. La funzione main ()" esportabile "in modo che possa essere utilizzata successivamente in un altro eseguibile da dll. Forse un esempio di dove lo usavo può essere utile.

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);
}



Quando si mischiano C e C ++ (ad esempio, una chiamata alla funzione C da C ++ e b chiamando la funzione C ++ da C), il nome del linguaggio C ++ causa problemi di collegamento. Tecnicamente parlando, questo problema si verifica solo quando le funzioni del callee sono già state compilate in binario (molto probabilmente, un file di libreria * .a) utilizzando il compilatore corrispondente.

Quindi abbiamo bisogno di usare "C" extern per disabilitare il nome mangling in C ++.




Related