c++中extern "c"的使用

時間  2019-11-13
標籤 c++ extern 使用 欄目 C&C++ 简体版
原文   原文鏈接

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

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

C代碼  函數

  1. #ifdef __cplusplus  this

  2. extern "C" {  spa

  3. #endif  .net

  4.   

  5. /**** some declaration or so *****/  code

  6.   

  7. #ifdef __cplusplus  orm

  8. }  接口

  9. #endif  ip

 

 

那麼，這種寫法什麼用呢？實際上，這是爲了讓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" {} 這種語法形式就是用來解決這個問題的。本文將以示例對這個問題進行說明。

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

C代碼  收藏代碼

  1. /* file: test_extern_c.h */  

  2.   

  3. #ifndef __TEST_EXTERN_C_H__  

  4. #define __TEST_EXTERN_C_H__  

  5.   

  6. #ifdef __cplusplus  

  7. extern "C" {  

  8. #endif  

  9.   

  10. /* 

  11. * this is a test function, which calculate 

  12. * the multiply of a and b. 

  13. */  

  14.   

  15. extern int ThisIsTest(int a, int b);  

  16.   

  17. #ifdef __cplusplus  

  18. }  

  19. #endif  

  20.   

  21. #endif   

 

 

在這個頭文件中只定義了一個函數，ThisIsTest() 。這個函數被定義爲一個外部函數，能夠被包括到其它程序文件中。假設ThisIsTest() 函數的實現位於test_extern_c.c 文件中：

C代碼  收藏代碼

  1. /* test_extern_c.c */  

  2.   

  3. ＃include "test_extern_c.h"  

  4.   

  5. int ThisIsTest(int a, int b)  

  6. {  

  7.   return (a + b);  

  8. }   

 

 

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

Cpp代碼  收藏代碼

  1. /* main.cpp */  

  2.   

  3. ＃include "test_extern_c.h"  

  4.   

  5. ＃include <stdio.h>  

  6. ＃include <stdlib.h>  

  7.   

  8. class FOO {  

  9.   

  10. public:  

  11.   

  12.   int bar(int a, int b)  

  13.   

  14.     {  

  15.   

  16.         printf("result=%i\n", ThisIsTest(a, b));  

  17.   

  18.     }  

  19.   

  20. };  

  21.   

  22. int main(int argc, char **argv)  

  23. {  

  24.   

  25.   int a = atoi(argv[1]);  

  26.   

  27.   int b = atoi(argv[2]);  

  28.   

  29.   FOO *foo = new FOO();  

  30.   

  31.   foo->bar(a, b);  

  32.   

  33.   return(0);  

  34. }   

 

在這個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 文件內容以下：

C代碼  收藏代碼

  1. /* test_extern_c.h */  

  2.   

  3. #ifndef __TEST_EXTERN_C_H__  

  4. #define __TEST_EXTERN_C_H__  

  5.   

  6. //#ifdef   __cplusplus  

  7. //extern "C" {  

  8. //#endif  

  9.   

  10. /* 

  11. /* this is a test function, which calculate 

  12. * the multiply of a and b. 

  13. */  

  14.   

  15. extern int ThisIsTest(int a, int b);  

  16.   

  17. //#ifdef   __cplusplus  

  18. // }  

  19. //#endif  

  20.   

  21. #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 用得不是不少，瞭解得也不多，所以對其內部處理機制並非很清楚，若是須要深刻了解這個問題的細節請參考相關資料。

 

注意：

用g++編譯cpp程序時，編譯器會定義宏 __cplusplus ,可根據__cplusplus是否認義決定是否須要extern "C"。

 

總結：

上面講的都是理論，和一些程序，那麼實際使用時有如下集中狀況：

1. 如今要寫一個c語言的模塊，供之後使用（之後的項目多是c的也多是c++的），源文件事先編譯好，編譯成.so或.o都無所謂。頭文件中聲明函數時要用條件編譯包含起來，以下：

 

C代碼  收藏代碼

  1. #ifdef __cpluscplus  

  2. extern "C" {  

  3. #endif  

  4.   

  5. //some code  

  6.   

  7. #ifdef __cplusplus  

  8. }  

  9. #endif  

也就是把全部函數聲明放在some code的位置。

2. 若是這個模塊已經存在了，多是公司裏的前輩寫的，反正就是已經存在了，模塊的.h文件中沒有extern "C"關鍵字，這個模塊又不但願被改動的狀況下，能夠這樣，在你的c++文件中，包含該模塊的頭文件時加上extern "C", 以下：

Cpp代碼  收藏代碼

  1. extern "C" {  

  2. #include "test_extern_c.h"  

  3. }  

 

       3.上面例子中，若是僅僅使用模塊中的1個函數，而不須要include整個模塊時，能夠不include頭文件，而單獨聲明該函數，像這樣:

 

Cpp代碼  收藏代碼

  1. extern "C" {  

  2. int ThisIsTest(int, int);  

  3. }  

 

而後就可一使用模塊中的這個ThisIsTest函數了。

相關文章
相關標籤/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公眾號
   歡迎關注本站公眾號,獲取更多信息
聯繫我們 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程