C和C++混合編譯，extern"C"的用法

2019-11-14 08:59:59

字體：大中小

供稿：網(wǎng)友

第一篇：轉(zhuǎn)載于C和C++混合編譯

關(guān)于extern_C 通常，在C語言的頭文件中經(jīng)常可以看到類似下面這種形式的代碼

#ifdef __cplusplus extern "C" { #endif /**** some declaration or so *****/ #ifdef __cplusplus } #endif /* end of __cplusplus */

那么，這種寫法什么用呢？實際上，這是為了讓CPP能夠與C接口而采用的一種語法形式。之所以采用這種方式，是因為兩種語言之間的一些差異所導(dǎo)致的。由于CPP支持多態(tài)性，也就是具有相同函數(shù)名的函數(shù)可以完成不同的功能，CPP通常是通過參數(shù)區(qū)分具體調(diào)用的是哪一個函數(shù)。在編譯的時候，CPP編譯器會將參數(shù)類型和函數(shù)名連接在一起，于是在程序編譯成為目標文件以后，CPP編譯器可以直接根據(jù)目標文件中的符號名將多個目標文件連接成一個目標文件或者可執(zhí)行文件。但是在C語言中，由于完全沒有多態(tài)性的概念，C編譯器在編譯時除了會在函數(shù)名前面添加一個下劃線之外，什么也不會做（至少很多編譯器都是這樣干的）。由于這種的原因，當(dāng)采用CPP與C混合編程的時候，就可能會出問題。假設(shè)在某一個頭文件中定義了這樣一個函數(shù)：

int foo(int a, int b);

而這個函數(shù)的實現(xiàn)位于一個.c文件中，同時，在.cpp文件中調(diào)用了這個函數(shù)。那么，當(dāng)CPP編譯器編譯這個函數(shù)的時候，就有可能會把這個函數(shù)名改成_fooii，這里的ii表示函數(shù)的第一參數(shù)和第二參數(shù)都是整型。而C編譯器卻有可能將這個函數(shù)名編譯成_foo。也就是說，在CPP編譯器得到的目標文件中，foo()函數(shù)是由_fooii符號來引用的，而在C編譯器生成的目標文件中，foo()函數(shù)是由_foo指代的。但連接器工作的時候，它可不管上層采用的是什么語言，它只認目標文件中的符號。于是，連接器將會發(fā)現(xiàn)在.cpp中調(diào)用了foo()函數(shù)，但是在其它的目標文件中卻找不到_fooii這個符號，于是提示連接過程出錯。extern “C” {}這種語法形式就是用來解決這個問題的。本文將以示例對這個問題進行說明。

首先假設(shè)有下面這樣三個文件：

/* 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

在這個頭文件中只定義了一個函數(shù)，ThisIsTest()。這個函數(shù)被定義為一個外部函數(shù)，可以被包括到其它程序文件中。假設(shè)ThisIsTest()函數(shù)的實現(xiàn)位于test_extern_c.c文件中：

/* test_extern_c.c */ #include "test_extern_c.h" int ThisIsTest(int a, int b) { return (a + b); }

可以看到，ThisIsTest()函數(shù)的實現(xiàn)非常簡單，就是將兩個參數(shù)的相加結(jié)果返回而已。現(xiàn)在，假設(shè)要從CPP中調(diào)用ThisIsTest()函數(shù)：

/* main.cpp */ #include "test_extern_c.h" #include <stdio.h> #include <stdlib.h> class FOO { public: int bar(int a, int b) { 在這個CPP源文件中，定義了一個簡單的類FOO，在其成員函數(shù)bar()中調(diào)用了ThisIsTest()函數(shù)。下面看一下如果采用gcc編譯test_extern_c.c，而采用g++編譯main.cpp并與test_extern_c.o連接會發(fā)生什么情況：

[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

可以看到，程序沒有任何異常，完全按照預(yù)期的方式工作。那么，如果將test_extern_c.h中的extern “C” {}所在的那幾行注釋掉會怎樣呢？注釋后的test_extern_c.h文件內(nèi)容如下：

/* 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提示找不到對函數(shù)ThisIsTest()的引用。

為了更清楚地說明問題的原因，我們采用下面的方式先把目標文件編譯出來，然后看目標文件中到底都有些什么符號：

可以看到，采用gcc編譯了test_extern_c.c之后，在其目標文件test_extern_c.o中的有一個ThisIsTest符號，這個符號就是源文件中定義的ThisIsTest()函數(shù)了。而在采用g++編譯了main.cpp之后，在其目標文件main.o中有一個_Z10ThisIsTestii符號，這個就是經(jīng)過g++編譯器“粉碎”過后的函數(shù)名。其最后的兩個字符i就表示第一參數(shù)和第二參數(shù)都是整型。而為什么要加一個前綴_Z10我并不清楚，但這里并不影響我們的討論，因此不去管它。顯然，這就是原因的所在，其原理在本文開頭已作了說明。

那么，為什么采用了extern “C” {}形式就不會有這個問題呢，我們就來看一下當(dāng)test_extern_c.h采用extern “C” {}的形式時編譯出來的目標文件中又有哪些符號：

[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()函數(shù)了。顯然，此時在兩個目標文件中都存在同樣的ThisIsTest符號，因此認為它們引用的實際上同一個函數(shù)，于是就將兩個目標文件連接在一起，凡是出現(xiàn)程序代碼段中有ThisIsTest符號的地方都用ThisIsTest()函數(shù)的實際地址代替。另外，還可以看到，僅僅被extern “C” {}包圍起來的函數(shù)采用這樣的目標符號形式，對于main.cpp中的FOO類的成員函數(shù)，在兩種編譯方式后的符號名都是經(jīng)過“粉碎”了的。

因此，綜合上面的分析，我們可以得出如下結(jié)論：采用extern “C” {} 這種形式的聲明，可以使得CPP與C之間的接口具有互通性，不會由于語言內(nèi)部的機制導(dǎo)致連接目標文件的時候出現(xiàn)錯誤。需要說明的是，上面只是根據(jù)我的試驗結(jié)果而得出的結(jié)論。由于對于CPP用得不是很多，了解得也很少，因此對其內(nèi)部處理機制并不是很清楚，如果需要深入了解這個問題的細節(jié)請參考相關(guān)資料。

備注： 1. 對于要在cpp中使用的在c文件中寫好的函數(shù)func()，只需要在c文件的頭文件中添加extern “C”聲明就可以了。比如：extern “C” func() { …}

當(dāng)然，可以使用

#ifdef __cplusplusextern "C" {#endif和#ifdef __cplusplus}#endif

將整個c文件的函數(shù)全都括起來。

第二篇：轉(zhuǎn)載于extern”C” 用法解析

引言

C++保留了一部分過程式語言的特點，因而它可以定義不屬于任何類的全局變量和函數(shù)。但是，C++畢竟是一種面向?qū)ο蟮某绦蛟O(shè)計語言，為了支持函數(shù)的重載，C++對全局函數(shù)的處理方式與C有明顯的不同。 extern “C”的主要作用就是為了能夠正確實現(xiàn)C++代碼調(diào)用其他C語言代碼。加上extern “C”后，會指示編譯器這部分代碼按C語言的進行編譯，而不是C++的。由于C++支持函數(shù)重載，因此編譯器編譯函數(shù)的過程中會將函數(shù)的參數(shù)類型也加到編譯后的代碼中，而不僅僅是函數(shù)名；而C語言并不支持函數(shù)重載，因此編譯C語言代碼的函數(shù)時不會帶上函數(shù)的參數(shù)類型，一般之包括函數(shù)名。比如說你用C 開發(fā)了一個DLL 庫，為了能夠讓C ++語言也能夠調(diào)用你的DLL輸出(Export)的函數(shù)，你需要用extern “C”來強制編譯器不要修改你的函數(shù)名。

揭秘extern “C”

從標準頭文件說起

#ifndef __INCvxWorksh /*防止該頭文件被重復(fù)引用*/#define __INCvxWorksh#ifdef __cplusplus //__cplusplus是cpp中自定義的一個宏extern "C" { //告訴編譯器，這部分代碼按C語言的格式進行編譯，而不是C++的#endif /**** some declaration or so *****/ #ifdef __cplusplus}#endif#endif /* __INCvxWorksh */

extern “C”的含義

extern “C” 包含雙重含義，從字面上即可得到：首先，被它修飾的目標是“extern”的；其次，被它修飾的目標是“C”的。被extern “C”限定的函數(shù)或變量是extern類型的； 1、extern關(guān)鍵字 extern是C/C++語言中表明函數(shù)和全局變量作用范圍（可見性）的關(guān)鍵字，該關(guān)鍵字告訴編譯器，其聲明的函數(shù)和變量可以在本模塊或其它模塊中使用。通常，在模塊的頭文件中對本模塊提供給其它模塊引用的函數(shù)和全局變量以關(guān)鍵字extern聲明。例如，如果模塊B欲引用該模塊A中定義的全局變量和函數(shù)時只需包含模塊A的頭文件即可。這樣，模塊B中調(diào)用模塊A中的函數(shù)時，在編譯階段，模塊B雖然找不到該函數(shù)，但是并不會報錯；它會在鏈接階段中從模塊A編譯生成的目標代碼中找到此函數(shù)。與extern對應(yīng)的關(guān)鍵字是static，被它修飾的全局變量和函數(shù)只能在本模塊中使用。因此，一個函數(shù)或變量只可能被本模塊使用時，其不可能被extern “C”修飾。

2、被extern “C”修飾的變量和函數(shù)是按照C語言方式編譯和鏈接的首先看看C++中對類似C的函數(shù)是怎樣編譯的。作為一種面向?qū)ο蟮恼Z言，C++支持函數(shù)重載，而過程式語言C則不支持。函數(shù)被C++編譯后在符號庫中的名字與C語言的不同。例如，假設(shè)某個函數(shù)的原型為： void foo( int x, int y ); 該函數(shù)被C編譯器編譯后在符號庫中的名字為_foo，而C++編譯器則會產(chǎn)生像_foo_int_int之類的名字（不同的編譯器可能生成的名字不同，但是都采用了相同的機制，生成的新名字稱為“mangled name”）。 _foo_int_int這樣的名字包含了函數(shù)名、函數(shù)參數(shù)數(shù)量及類型信息，C++就是靠這種機制來實現(xiàn)函數(shù)重載的。例如，在C++中，函數(shù)void foo( int x, int y )與void foo( int x, float y )編譯生成的符號是不相同的，后者為_foo_int_float。同樣地，C++中的變量除支持局部變量外，還支持類成員變量和全局變量。用戶所編寫程序的類成員變量可能與全局變量同名，我們以”.”來區(qū)分。而本質(zhì)上，編譯器在進行編譯時，與函數(shù)的處理相似，也為類中的變量取了一個獨一無二的名字，這個名字與用戶程序中同名的全局變量名字不同。

3、舉例說明（1）未加extern “C”聲明時的連接方式假設(shè)在C++中，模塊A的頭文件如下：

// 模塊A頭文件　moduleA.h#ifndef MODULE_A_H#define MODULE_A_Hint foo( int x, int y );#endif//在模塊B中引用該函數(shù)：// 模塊B實現(xiàn)文件　moduleB.cpp#include "moduleA.h"foo(2,3);

實際上，在連接階段，鏈接器會從模塊A生成的目標文件moduleA.obj中尋找_foo_int_int這樣的符號！

（2）加extern “C”聲明后的編譯和鏈接方式加extern “C”聲明后，模塊A的頭文件變?yōu)椋?/p>// 模塊A頭文件　moduleA.h#ifndef MODULE_A_H#define MODULE_A_Hextern "C" int foo( int x, int y );#endif

在模塊B的實現(xiàn)文件中仍然調(diào)用foo( 2,3 )，其結(jié)果是：

<1>A編譯生成foo的目標代碼時，沒有對其名字進行特殊處理，采用了C語言的方式；

<2>鏈接器在為模塊B的目標代碼尋找foo(2,3)調(diào)用時，尋找的是未經(jīng)修改的符號名_foo。

如果在模塊A中函數(shù)聲明了foo為extern “C”類型，而模塊B中包含的是extern int foo(int x, int y)，則模塊B找不到模塊A中的函數(shù)；反之亦然。

extern “C”這個聲明的真實目的是為了實現(xiàn)C++與C及其它語言的混合編程。

應(yīng)用場合

C++代碼調(diào)用C語言代碼、在C++的頭文件中使用在C++中引用C語言中的函數(shù)和變量，在包含C語言頭文件（假設(shè)為cExample.h）時，需進行下列處理：

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

而在C語言的頭文件中，對其外部函數(shù)只能指定為extern類型，C語言中不支持extern “C”聲明，在.c文件中包含了extern “C”時會出現(xiàn)編譯語法錯誤。

/* c語言頭文件：cExample.h */#ifndef C_EXAMPLE_H#define C_EXAMPLE_Hextern int add(int x,int y); //注:寫成extern "C" int add(int , int ); 也可以#endif/* c語言實現(xiàn)文件：cExample.c */#include "cExample.h"int add( int x, int y ){　return x + y;}// c++實現(xiàn)文件，調(diào)用add：cppFile.cppextern "C"{　#include "cExample.h" //注：此處不妥，如果這樣編譯通不過，換成 extern "C" int add(int , int ); 可以通過}int main(int argc, char* argv[]){　add(2,3);　return 0;}

如果C++調(diào)用一個C語言編寫的.DLL時，當(dāng)包括.DLL的頭文件或聲明接口函數(shù)時，應(yīng)加extern “C”{}。

在C中引用C++語言中的函數(shù)和變量時，C++的頭文件需添加extern “C”，但是在C語言中不能直接引用聲明了extern “C”的該頭文件，應(yīng)該僅將C文件中將C++中定義的extern “C”函數(shù)聲明為extern類型