¿Cuál es el efecto de la "C" externa en C ++?

¿Qué hace exactamente poner extern "C"en código C ++?

Por ejemplo:

extern "C" {
   void foo();
}

Extern "C" hace que un nombre de función en C ++ tenga un enlace 'C' (el compilador no daña el nombre) para que el código C del cliente pueda enlazar (es decir, usar) su función usando un archivo de encabezado compatible 'C' que contenga solo el declaración de su función. La definición de su función está contenida en un formato binario (que fue compilado por su compilador de C ++) que el enlazador 'C' del cliente vinculará utilizando el nombre 'C'.

Dado que C ++ tiene una sobrecarga de nombres de funciones y C no, el compilador de C ++ no puede usar el nombre de la función como una identificación única para vincular, por lo que desbarata el nombre agregando información sobre los argumentos. El compilador de CA no necesita alterar el nombre, ya que no puede sobrecargar los nombres de funciones en C. Cuando declara que una función tiene un enlace externo "C" en C ++, el compilador de C ++ no agrega información de tipo de argumento / parámetro al nombre utilizado para enlace.

Para que lo sepas, puedes especificar explícitamente el enlace "C" a cada declaración / definición individual o usar un bloque para agrupar una secuencia de declaraciones / definiciones para tener un cierto enlace:

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

Si le interesan los tecnicismos, se enumeran en la sección 7.5 del estándar C ++ 03, aquí hay un breve resumen (con énfasis en la "C" externa):

• extern "C" es una especificación de enlace
• Todos los compiladores deben proporcionar un enlace "C"
• una especificación de vinculación debe ocurrir solo en el alcance del espacio de nombres
• todos los tipos de funciones, nombres de funciones y nombres de variables tienen un enlace de idioma. Vea el comentario de Richard: Solo los nombres de funciones y nombres de variables con enlace externo tienen un enlace de idioma.
• dos tipos de funciones con enlaces de idiomas distintos son tipos distintos incluso si son idénticos
• las especificaciones de vinculación anidan, la interna determina la vinculación final
• la "C" externa se ignora para los miembros de la clase
• a lo sumo, una función con un nombre particular puede tener un enlace "C" (independientemente del espacio de nombres)
• extern "C" obliga a una función a tener un enlace externo (no puede hacerla estática) Ver el comentario de Richard: 'static' dentro de 'extern "C"' es válido; una entidad así declarada tiene un enlace interno y, por lo tanto, no tiene un enlace de idioma
• La vinculación de C ++ a objetos definidos en otros lenguajes y a objetos definidos en C ++ de otros lenguajes está definida por la implementación y depende del lenguaje. Solo cuando las estrategias de diseño de objetos de las implementaciones de dos idiomas son lo suficientemente similares, se puede lograr dicha vinculación

Solo quería agregar un poco de información, ya que no lo he visto publicado aún.

Muy a menudo verá el código en los encabezados C de esta manera:

#ifdef __cplusplus
extern "C" {
#endif

// all of your legacy C code here

#ifdef __cplusplus
}
#endif

Lo que esto logra es que le permite usar ese archivo de encabezado C con su código C ++, porque se definirá la macro "__cplusplus". Pero se puede también todavía utilizarlo con su código heredado C, donde la macro no definida, por lo que no verá la única construcción de C ++.

Aunque, también he visto código C ++ como:

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

que me imagino logra casi lo mismo.

No estoy seguro de qué manera es mejor, pero he visto ambos.

Descompile un g++binario generado para ver qué está pasando

main.cpp

void f() {}
void g();

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

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

Compile y desarme la salida ELF generada :

g++ -c -std=c++11 -Wall -Wextra -pedantic -o main.o main.cpp
readelf -s main.o

La salida contiene:

     8: 0000000000000000     7 FUNC    GLOBAL DEFAULT    1 _Z1fv
     9: 0000000000000007     7 FUNC    GLOBAL DEFAULT    1 ef
    10: 000000000000000e    17 FUNC    GLOBAL DEFAULT    1 _Z1hv
    11: 0000000000000000     0 NOTYPE  GLOBAL DEFAULT  UND _GLOBAL_OFFSET_TABLE_
    12: 0000000000000000     0 NOTYPE  GLOBAL DEFAULT  UND _Z1gv
    13: 0000000000000000     0 NOTYPE  GLOBAL DEFAULT  UND eg

Interpretación

Vemos eso:

• efy egse almacenaron en símbolos con el mismo nombre que en el código

• los otros símbolos fueron destrozados. Vamos a deshacerlos:

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

Conclusión: los dos tipos de símbolos siguientes no fueron destrozados:

• definido
• declarado pero indefinido ( Ndx = UND), que se proporcionará en el enlace o en el tiempo de ejecución desde otro archivo de objeto

Entonces necesitará extern "C"ambos cuando llame:

• C de C ++: diga g++que espere símbolos sin desencadenar producidos porgcc
• C ++ desde C: diga g++que genere símbolos sin desenvolver para gccusar

Cosas que no funcionan en el exterior C

Resulta obvio que cualquier característica de C ++ que requiera el cambio de nombre no funcionará en el interior 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) { }
}

Ejemplo mínimo de C ejecutable desde C ++

En aras de la exhaustividad y para los novatos, vea también: ¿Cómo usar archivos fuente C en un proyecto C ++?

Llamar a C desde C ++ es bastante fácil: cada función de C solo tiene un posible símbolo no mutilado, por lo que no se requiere trabajo adicional.

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++ 
 * because C does not know what this extern "C" thing is. */
#ifdef __cplusplus
extern "C" {
#endif
int f();
#ifdef __cplusplus
}
#endif

#endif

cc

#include "c.h"

int f(void) { return 1; }

Correr:

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

Sin extern "C"el enlace falla con:

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

porque g++espera encontrar un destrozado f, que gccno produjo.

Ejemplo en GitHub .

Ejemplo de C ++ ejecutable mínimo desde C

Llamar a C ++ desde C es un poco más difícil: tenemos que crear manualmente versiones no mutiladas de cada función que queremos exponer.

Aquí ilustramos cómo exponer sobrecargas de la función C ++ a C.

C Principal

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

Correr:

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

Sin extern "C"falla con:

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

porque g++generó símbolos destrozados que gccno pueden encontrar.

Ejemplo en GitHub .

Probado en Ubuntu 18.04.

En cada programa C ++, todas las funciones no estáticas se representan en el archivo binario como símbolos. Estos símbolos son cadenas de texto especiales que identifican de forma única una función en el programa.

En C, el nombre del símbolo es el mismo que el nombre de la función. Esto es posible porque en C no hay dos funciones no estáticas que puedan tener el mismo nombre.

Debido a que C ++ permite la sobrecarga y tiene muchas características que C no tiene, como clases, funciones miembro, especificaciones de excepción, no es posible usar simplemente el nombre de la función como el nombre del símbolo. Para resolver eso, C ++ usa el llamado cambio de nombre, que transforma el nombre de la función y toda la información necesaria (como el número y el tamaño de los argumentos) en una cadena de aspecto extraño procesada solo por el compilador y el enlazador.

Entonces, si especifica que una función sea externa C, el compilador no realiza el cambio de nombre con ella y se puede acceder directamente usando su nombre de símbolo como el nombre de la función.

Esto resulta útil durante el uso dlsym()y dlopen()para llamar a tales funciones.

C ++ manipula nombres de funciones para crear un lenguaje orientado a objetos a partir de un lenguaje de procedimiento

La mayoría de los lenguajes de programación no están construidos sobre los lenguajes de programación existentes. C ++ está construido sobre C, y además es un lenguaje de programación orientado a objetos construido a partir de un lenguaje de programación procesal, y por esa razón hay expresiones de C ++ extern "C"que proporcionan compatibilidad con C.

Veamos el siguiente ejemplo:

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

El compilador de CA no compilará el ejemplo anterior, porque la misma función printMese define dos veces (a pesar de que tienen diferentes parámetros int avs char a).

gcc -o printMe printMe.c && ./printMe;
1 error PrintMe se define más de una vez.

Un compilador de C ++ compilará el ejemplo anterior. No le importa que printMese defina dos veces.

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

Esto se debe a que un compilador de C ++ renombra implícitamente ( alterar ) las funciones en función de sus parámetros. En C, esta característica no era compatible. Sin embargo, cuando C ++ fue construido sobre C, el idioma se diseñó para ser orientado a objetos, y necesitaba para soportar la capacidad de crear diferentes clases con los métodos (funciones) del mismo nombre, y para anular métodos ( método imperiosas ) basados en diferentes parámetros

extern "C" dice "no alterar los nombres de las funciones C"

Sin embargo, imagine que tenemos un archivo C heredado llamado "parent.c" que contiene includenombres de funciones de otros archivos C heredados, "parent.h", "child.h", etc. Si se ejecuta el archivo "parent.c" heredado a través de un compilador de C ++, los nombres de las funciones se modificarán y ya no coincidirán con los nombres de las funciones especificadas en "parent.h", "child.h", etc., por lo que los nombres de las funciones en esos archivos externos también deberían ser destrozado El cambio de nombres de funciones en un programa C complejo, aquellos con muchas dependencias, puede conducir a un código roto; por lo tanto, puede ser conveniente proporcionar una palabra clave que pueda indicarle al compilador de C ++ que no altere el nombre de una función.

La extern "C"palabra clave le dice a un compilador de C ++ que no altere (renombre) los nombres de las funciones de C.

Por ejemplo:

extern "C" void printMe(int a);

Ningún encabezado C se puede hacer compatible con C ++ simplemente envolviendo en "C" externa. Cuando los identificadores en un encabezado C entran en conflicto con las palabras clave de C ++, el compilador de C ++ se quejará de esto.

Por ejemplo, he visto fallar el siguiente código en un g ++:

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

Tiene sentido, pero es algo a tener en cuenta al portar código C a C ++.

Cambia el enlace de una función de tal manera que la función se puede llamar desde C. En la práctica, eso significa que el nombre de la función no está destrozado .

Informa al compilador de C ++ que busque los nombres de esas funciones en un estilo C al vincular, porque los nombres de las funciones compiladas en C y C ++ son diferentes durante la etapa de vinculación.

Extern "C" está destinado a ser reconocido por un compilador de C ++ y notificar al compilador que la función anotada se compila (o se compilará) en estilo C. De modo que mientras se vincula, se vincula a la versión correcta de la función de C.

Utilicé 'extern "C"' antes para que los archivos dll (biblioteca de enlaces dinámicos) hicieran que la función main () fuera "exportable", de modo que pueda usarse más tarde en otro ejecutable desde dll. Quizás un ejemplo de dónde solía usarlo puede ser útil.

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

extern "C"es una especificación de enlace que se utiliza para llamar a funciones C en los archivos fuente de Cpp . Podemos llamar a funciones C, escribir variables e incluir encabezados . La función se declara en entidad externa y se define afuera. La sintaxis es

Tipo 1:

extern "language" function-prototype

Tipo 2:

extern "language"
{
     function-prototype
};

p.ej:

#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)
{
    //
    //
}

Esta respuesta es para los impacientes / tienen plazos para cumplir, solo una explicación parcial / simple está a continuación:

• en C ++, puede tener el mismo nombre en clase a través de la sobrecarga (por ejemplo, dado que todos tienen el mismo nombre no se pueden exportar tal cual desde dll, etc.) la solución a estos problemas es que se convierten en cadenas diferentes (llamadas símbolos ), los símbolos representan el nombre de la función, también los argumentos, por lo que cada una de estas funciones, incluso con el mismo nombre, se puede identificar de forma única (también llamada, cambio de nombre)
• en C, no tiene sobrecarga, el nombre de la función es único (por lo tanto, no se requiere una cadena separada para identificar el nombre de una función de manera única, por lo que el símbolo es el nombre de la función en sí)

Entonces,
en C ++, con el cambio de nombre identifica de forma única cada función
en C, incluso sin el cambio de nombre identifica de forma única cada función

Para cambiar el comportamiento de C ++, es decir, para especificar que el cambio de nombre no debe ocurrir para una función en particular, puede usar "C" externa antes del nombre de la función, por cualquier razón, como exportar una función con un nombre específico desde un dll , para uso de sus clientes.

Lea otras respuestas, para obtener respuestas más detalladas / más correctas.

Al mezclar C y C ++ (es decir, a. Llamar a la función C desde C ++; y b. Llamar a la función C ++ desde C), el cambio de nombre de C ++ causa problemas de vinculación. Técnicamente hablando, este problema ocurre solo cuando las funciones de la persona que llama ya se han compilado en binario (muy probablemente, un archivo de biblioteca * .a) usando el compilador correspondiente.

Por lo tanto, necesitamos usar "C" externa para deshabilitar el cambio de nombre en C ++.

Sin entrar en conflicto con otras buenas respuestas, agregaré un poco de mi ejemplo.

Qué hace exactamente el compilador de C ++ : altera los nombres en el proceso de compilación, por lo tanto, debemos decirle al compilador que trate la C implementación especialmente.

Cuando estamos haciendo clases de C ++ y agregando extern "C", le estamos diciendo a nuestro compilador de C ++ que estamos usando la convención de llamadas de C ++.

Motivo (estamos llamando a la implementación de C desde C ++): o bien queremos llamar a la función de C desde C ++ o llamar a la función de C ++ desde C (las clases de C ++ ... etc. no funcionan en C).

Una función void f () compilada por un compilador de C y una función con el mismo nombre void f () compilada por un compilador de C ++ no son la misma función. Si escribió esa función en C, y luego intentó llamarla desde C ++, entonces el enlazador buscaría la función C ++ y no la encontraría.

extern "C" le dice al compilador de C ++ que tiene una función que fue compilada por el compilador de C. Una vez que le diga que fue compilado por el compilador de C, el compilador de C ++ sabrá cómo llamarlo correctamente.

También permite que el compilador de C ++ compile una función de C ++ de tal manera que el compilador de C ++ pueda llamarla. Esa función sería oficialmente una función de C, pero como está compilada por el compilador de C ++, puede usar todas las funciones de C ++ y tiene todas las palabras clave de C ++.