C和C++混合編程(__cplusplus 與 external "c" 的使用)

轉自：http://blog.csdn.net/ljfth/article/details/3965871

第一種理解
好比說你用C++開發了一個DLL庫，爲了可以讓C語言也可以調用你的DLL輸出(Export)的函數，你須要用extern "C"來強制編譯器不要修改你的

函數名。

一般，在C語言的頭文件中常常能夠看到相似下面這種形式的代碼：

#ifdef __cplusplus

extern "C" {

#endif

/**** some declaration or so *****/

#ifdef __cplusplus

  }

#endif /* end of __cplusplus */

那麼，這種寫法什麼用呢？實際上，這是爲了讓CPP可以與C接口而採用的一種語法形式。之因此採用這種方式，是由於兩種語言之間的一些差

異所致使的。因爲CPP支持多態性，也就是具備相同函數名的函數能夠完成不一樣的功能，CPP一般是經過參數區分具體調用的是哪個函數。在

編譯的時候，CPP編譯器會將參數類型和函數名鏈接在一塊兒，因而在程序編譯成爲目標文件之後，CPP編譯器能夠直接根據目標文件中的符號名

將多個目標文件鏈接成一個目標文件或者可執行文件。可是在C語言中，因爲徹底沒有多態性的概念，C編譯器在編譯時除了會在函數名前面添

加一個下劃線以外，什麼也不會作（至少不少編譯器都是這樣乾的）。因爲這種的緣由，當採用CPP與C混合編程的時候，就可能會出問題。假

設在某一個頭文件中定義了這樣一個函數：

int foo(int a, int b);

而這個函數的實現位於一個.c文件中，同時，在.cpp文件中調用了這個函數。那麼，當CPP編譯器編譯這個函數的時候，就有可能會把這個函數

名改爲_fooii，這裏的ii表示函數的第一參數和第二參數都是整型。而C編譯器卻有可能將這個函數名編譯成_foo。也就是說，在CPP編譯器得

到的目標文件中，foo()函數是由_fooii符號來引用的，而在C編譯器生成的目標文件中，foo()函數是由_foo指代的。但鏈接器工做的時候，它

可無論上層採用的是什麼語言，它只認目標文件中的符號。因而，鏈接器將會發如今.cpp中調用了foo()函數，可是在其它的目標文件中卻找不

到_fooii這個符號，因而提示鏈接過程出錯。extern "C" {}這種語法形式就是用來解決這個問題的。本文將以示例對這個問題進行說明。

首先假設有下面這樣三個文件：

/* file: test_extern_c.h */

#ifndef __TEST_EXTERN_C_H__

#define __TEST_EXTERN_C_H__

#ifdef __cplusplus

extern "C" {

#endif

/*

* this is a test function, which calculate

* the multiply of a and b.

*/

extern int ThisIsTest(int a, int b);

#ifdef __cplusplus

  }

#endif /* end of __cplusplus */

#endif

在這個頭文件中只定義了一個函數，ThisIsTest()。這個函數被定義爲一個外部函數，能夠被包括到其它程序文件中。假設ThisIsTest()函數

的實現位於test_extern_c.c文件中：

/* test_extern_c.c */

#include "test_extern_c.h"

int ThisIsTest(int a, int b)

{

  return (a + b);

}

能夠看到，ThisIsTest()函數的實現很是簡單，就是將兩個參數的相加結果返回而已。如今，假設要從CPP中調用ThisIsTest()函數：

/* main.cpp */

#include "test_extern_c.h"

#include <stdio.h>

#include <stdlib.h>

class FOO {

  public:

  int bar(int a, int b)

    {

        printf("result=%i/n", ThisIsTest(a, b));

    }

};

int main(int argc, char **argv)

{

  int a = atoi(argv[1]);

  int b = atoi(argv[2]);

  FOO *foo = new FOO();

  foo->bar(a, b);

  return(0);

}

在這個CPP源文件中，定義了一個簡單的類FOO，在其成員函數bar()中調用了ThisIsTest()函數。下面看一下若是採用gcc編譯test_extern_c.c

，而採用g++編譯main.cpp並與test_extern_c.o鏈接會發生什麼狀況：

[cyc@cyc src]$ gcc -c test_extern_c.c

[cyc@cyc src]$ g++ main.cpp test_extern_c.o

[cyc@cyc src]$ ./a.out 4 5          

result=9

能夠看到，程序沒有任何異常，徹底按照預期的方式工做。那麼，若是將test_extern_c.h中的extern "C" {}所在的那幾行註釋掉會怎樣呢？

註釋後的test_extern_c.h文件內容以下：

/* test_extern_c.h */

#ifndef __TEST_EXTERN_C_H__

#define __TEST_EXTERN_C_H__

//#ifdef   __cplusplus

//extern "C" {

//#endif

/*

/* this is a test function, which calculate

* the multiply of a and b.

*/

extern int ThisIsTest(int a, int b);

//#ifdef   __cplusplus

// }

//#endif   /* end of __cplusplus */

#endif

以外，其它文件不作任何的改變，仍然採用一樣的方式編譯test_extern_c.c和main.cpp文件：

[cyc@cyc src]$ gcc -c test_extern_c.c

[cyc@cyc src]$ g++ main.cpp test_extern_c.o

/tmp/cca4EtJJ.o(.gnu.linkonce.t._ZN3FOO3barEii+0x10): In function `FOO::bar(int, int)':

: undefined reference to `ThisIsTest(int, int)'

collect2: ld returned 1 exit status

在編譯main.cpp的時候就會出錯，鏈接器ld提示找不到對函數ThisIsTest()的引用。

爲了更清楚地說明問題的緣由，咱們採用下面的方式先把目標文件編譯出來，而後看目標文件中到底都有些什麼符號：

[cyc@cyc src]$ gcc -c test_extern_c.c  

[cyc@cyc src]$ objdump -t test_extern_c.o

test_extern_c.o:   file format elf32-i386

SYMBOL TABLE:

00000000 l   df *ABS* 00000000 test_extern_c.c

00000000 l   d .text 00000000

00000000 l   d .data 00000000

00000000 l   d .bss   00000000

00000000 l   d .comment     00000000

00000000 g   F .text 0000000b ThisIsTest

[cyc@cyc src]$ g++ -c main.cpp      

[cyc@cyc src]$ objdump -t main.o      

main.o:   file format elf32-i386

MYMBOL TABLE:

00000000 l   df *ABS* 00000000 main.cpp

00000000 l   d .text 00000000

00000000 l   d .data 00000000

00000000 l   d .bss   00000000

00000000 l   d .rodata     00000000

00000000 l   d .gnu.linkonce.t._ZN3FOO3barEii 00000000

00000000 l   d .eh_frame     00000000

00000000 l   d .comment     00000000

00000000 g   F .text 00000081 main

00000000       *UND* 00000000 atoi

00000000       *UND* 00000000 _Znwj

00000000       *UND* 00000000 _ZdlPv

00000000 w   F .gnu.linkonce.t._ZN3FOO3barEii 00000027 _ZN3FOO3barEii

00000000       *UND* 00000000 _Z10ThisIsTestii

00000000       *UND* 00000000 printf

00000000       *UND* 00000000 __gxx_personality_v0

能夠看到，採用gcc編譯了test_extern_c.c以後，在其目標文件test_extern_c.o中的有一個ThisIsTest符號，這個符號就是源文件中定義的

ThisIsTest()函數了。而在採用g++編譯了main.cpp以後，在其目標文件main.o中有一個_Z10ThisIsTestii符號，這個就是通過g++編譯器「粉

碎」事後的函數名。其最後的兩個字符i就表示第一參數和第二參數都是整型。而爲何要加一個前綴_Z10我並不清楚，但這裏並不影響咱們的

討論，所以不去管它。顯然，這就是緣由的所在，其原理在本文開頭已做了說明。

那麼，爲何採用了extern "C" {}形式就不會有這個問題呢，咱們就來看一下當test_extern_c.h採用extern "C" {}的形式時編譯出來的目標

文件中又有哪些符號：

[cyc@cyc src]$ gcc -c test_extern_c.c

[cyc@cyc src]$ objdump -t test_extern_c.o

test_extern_c.o:   file format elf32-i386

SYMBOL TABLE:

00000000 l   df *ABS* 00000000 test_extern_c.c

00000000 l   d .text 00000000

00000000 l   d .data 00000000

00000000 l   d .bss   00000000

00000000 l   d .comment     00000000

00000000 g   F .text 0000000b ThisIsTest

[cyc@cyc src]$ g++ -c main.cpp

[cyc@cyc src]$ objdump -t main.o

main.o:   file format elf32-i386

SYMBOL TABLE:

00000000 l   df *ABS* 00000000 main.cpp

00000000 l   d .text 00000000

00000000 l   d .data 00000000

00000000 l   d .bss   00000000

00000000 l   d .rodata     00000000

00000000 l   d .gnu.linkonce.t._ZN3FOO3barEii 00000000

00000000 l   d .eh_frame     00000000

00000000 l   d .comment     00000000

00000000 g   F .text 00000081 main

00000000       *UND* 00000000 atoi

00000000       *UND* 00000000 _Znwj

00000000       *UND* 00000000 _ZdlPv

00000000 w   F .gnu.linkonce.t._ZN3FOO3barEii 00000027 _ZN3FOO3barEii

00000000       *UND* 00000000 ThisIsTest

00000000       *UND* 00000000 printf

00000000       *UND* 00000000 __gxx_personality_v0

注意到這裏和前面有什麼不一樣沒有，能夠看到，在兩個目標文件中，都有一個符號ThisIsTest，這個符號引用的就是ThisIsTest()函數了。顯

然，此時在兩個目標文件中都存在一樣的ThisIsTest符號，所以認爲它們引用的實際上同一個函數，因而就將兩個目標文件鏈接在一塊兒，凡是

出現程序代碼段中有ThisIsTest符號的地方都用ThisIsTest()函數的實際地址代替。另外，還能夠看到，僅僅被extern "C" {}包圍起來的函數

採用這樣的目標符號形式，對於main.cpp中的FOO類的成員函數，在兩種編譯方式後的符號名都是通過「粉碎」了的。

所以，綜合上面的分析，咱們能夠得出以下結論：採用extern "C" {} 這種形式的聲明，可使得CPP與C之間的接口具備互通性，不會因爲語

言內部的機制致使鏈接目標文件的時候出現錯誤。須要說明的是，上面只是根據個人試驗結果而得出的結論。因爲對於CPP用得不是不少，瞭解

得也不多，所以對其內部處理機制並非很清楚，若是須要深刻了解這個問題的細節請參考相關資料。

 

第二種理解
時常在cpp的代碼之中看到這樣的代碼:

#ifdef __cplusplus

extern "C" {

#endif

 

//一段代碼

 

#ifdef __cplusplus

}

#endif
 

　　這樣的代碼究竟是什麼意思呢？首先，__cplusplus是cpp中的自定義宏，那麼定義了這個宏的話表示這是一段cpp的代碼，也就是說，上面

的代碼的含義是:若是這是一段cpp的代碼，那麼加入extern "C"{和}處理其中的代碼。

　　要明白爲什麼使用extern "C"，還得從cpp中對函數的重載處理開始提及。在c++中，爲了支持重載機制，在編譯生成的彙編碼中，要對函數

的名字進行一些處理，加入好比函數的返回類型等等.而在C中，只是簡單的函數名字而已，不會加入其餘的信息.也就是說:C++和C對產生的函

數名字的處理是不同的.

　　好比下面的一段簡單的函數，咱們看看加入和不加入extern "C"產生的彙編代碼都有哪些變化:

int f(void)

{

return 1;

}
 

　　在加入extern "C"的時候產生的彙編代碼是:

.file "test.cxx"

.text

.align 2

.globl _f

.def _f; .scl 2; .type 32; .endef

_f:

pushl %ebp

movl %esp， %ebp

movl $1， %eax

popl %ebp

ret
 

　　可是不加入了extern "C"以後

.file "test.cxx"

.text

.align 2

.globl __Z1fv

.def __Z1fv; .scl 2; .type 32; .endef

__Z1fv:

pushl %ebp

movl %esp， %ebp

movl $1， %eax

popl %ebp

ret
 

　　兩段彙編代碼一樣都是使用gcc -S命令產生的，全部的地方都是同樣的，惟獨是產生的函數名，一個是_f，一個是__Z1fv。

　　明白了加入與不加入extern "C"以後對函數名稱產生的影響，咱們繼續咱們的討論:爲何須要使用extern "C"呢？C++之父在設計C++之時

，考慮到當時已經存在了大量的C代碼，爲了支持原來的C代碼和已經寫好C庫，須要在C++中儘量的支持C，而extern "C"就是其中的一個策略

。

　　試想這樣的狀況:一個庫文件已經用C寫好了並且運行得很良好，這個時候咱們須要使用這個庫文件，可是咱們須要使用C++來寫這個新的代

碼。若是這個代碼使用的是C++的方式連接這個C庫文件的話，那麼就會出現連接錯誤.咱們來看一段代碼:首先，咱們使用C的處理方式來寫一個

函數，也就是說假設這個函數當時是用C寫成的:

//f1.c

extern "C"

{

void f1()

{

return;

}

}
 

　　編譯命令是:gcc -c f1.c -o f1.o 產生了一個叫f1.o的庫文件。再寫一段代碼調用這個f1函數:

// test.cxx

//這個extern表示f1函數在別的地方定義，這樣能夠經過

//編譯，可是連接的時候仍是須要

//連接上原來的庫文件.

extern void f1();

 

int main()

{

f1();

 

return 0;

}
 

　　經過gcc -c test.cxx -o test.o 產生一個叫test.o的文件。而後，咱們使用gcc test.o f1.o來連接兩個文件，但是出錯了，錯誤的提示

是:

test.o(.text + 0x1f):test.cxx: undefine reference to 'f1()'
 

　　也就是說，在編譯test.cxx的時候編譯器是使用C++的方式來處理f1()函數的，可是實際上連接的庫文件倒是用C的方式來處理函數的，所

以就會出現連接過不去的錯誤:由於連接器找不到函數。

　　所以，爲了在C++代碼中調用用C寫成的庫文件，就須要用extern "C"來告訴編譯器:這是一個用C寫成的庫文件，請用C的方式來連接它們。

　　好比，如今咱們有了一個C庫文件，它的頭文件是f.h，產生的lib文件是f.lib，那麼咱們若是要在C++中使用這個庫文件，咱們須要這樣寫

:

extern "C"

{

#include "f.h"

}
 

　　回到上面的問題，若是要改正連接錯誤，咱們須要這樣子改寫test.cxx:

extern "C"

{

extern void f1();

}

 

int main()

{

f1();

 

return 0;

}
 

從新編譯而且連接就能夠過去了.

總結

C和C++對函數的處理方式是不一樣的.extern "C"是使C++可以調用C寫做的庫文件的一個手段，若是要對編譯器提示使用C的方式來處理函數的話，那麼就要使用extern "C"來講明。