[簡介][]
<h2>目錄</h2>
<ul>
<li><a href="#orgheadline19">1. 關于 <code>C++</code> 中的 extern "C"</a>
<ul>
<li><a href="#orgheadline1">1.1. 簡介</a></li>
<li><a href="#orgheadline4">1.2. 問題的引出</a>
<ul>
<li><a href="#orgheadline2">1.2.1. 某企業曾經給出如下的一道面試題</a></li>
<li><a href="#orgheadline3">1.2.2. 問題分析</a></li>
</ul>
</li>
<li><a href="#orgheadline10">1.3. 關于 extern "C"</a>
<ul>
<li><a href="#orgheadline5">1.3.1. 被 extern "C" 限定的函數或變量是 <code>extern</code> 類型的。</a></li>
<li><a href="#orgheadline9">1.3.2. 被 extern "C" 修飾的變量和函數是按照 <code>C</code> 語言方式編譯和連接的。</a>
<ul>
<li><a href="#orgheadline6">1.3.2.1. 首先看看 <code>C++</code> 中，在未加 extern "C" 聲明時，對類似 <code>C</code> 的函數是怎樣編譯的。</a></li>
<li><a href="#orgheadline7">1.3.2.2. 其次，看看在未加 extern "C" 聲明時，是如何連接的。</a></li>
<li><a href="#orgheadline8">1.3.2.3. 再者，看看加 extern "C" 聲明后的編譯和連接方式</a></li>
</ul>
</li>
</ul>
</li>
<li><a href="#orgheadline14">1.4. 用法舉例</a>
<ul>
<li><a href="#orgheadline11">1.4.1. <code>C++</code> 引用 <code>C</code> 函數的具體例子</a></li>
<li><a href="#orgheadline12">1.4.2. <code>C</code> 引用 <code>C++</code> 函數的具體例子</a></li>
<li><a href="#orgheadline13">1.4.3. 對 <code>__BEGIN_DECLS</code> 和 <code>__END_DECLS</code> 的理解</a></li>
</ul>
</li>
<li><a href="#orgheadline18">1.5. 總結</a>
<ul>
<li><a href="#orgheadline15">1.5.1. extern "C" 只是 <code>C++</code> 的關鍵字，不是 <code>C</code> 的</a></li>
<li><a href="#orgheadline16">1.5.2. 被 extern "C" 修飾的目標一般是對一個C或者 <code>C++</code> 函數的聲明</a></li>
<li><a href="#orgheadline17">1.5.3. extern "C" 這個關鍵字聲明的真實目的，就是實現 <code>C++</code> 與C及其它語言的混合編程</a></li>
</ul>
</li>
</ul>
</li>
</ul>
關于 C++ 中的 extern "C"<a id="orgheadline19"></a>
簡介 {#orgheadline1}
C++ 語言的創建初衷是 "a better C"，但是這并不意味著 C++ 中類似 C 語言的全局變量和函數所采用的編譯和連接方式與 C 語言完全相同。作為一種欲與 C 兼容的語言， C++ 保留了一部分過程式語言的特點（被世人稱為"不徹底地面向對象"），因而它可以定義不屬于任何類的全局變量和函數。但是， C++ 畢竟是一種面向對象的程序設計語言，為了支持函數的重載， C++ 對全局函數的處理方式與 C 有明顯的不同。
本文將介紹 C++ 中如何通過 extern "C" 關鍵字支持 C 語言。
{#問題的引出}<a id="orgheadline4"></a>
某企業曾經給出如下的一道面試題<a id="orgheadline2"></a>
為什么標準頭文件都有類似以下的結構？
//incvxworks.h
#ifndef __INCvxWorksh
#define __INCvxWorksh
#ifdef __cplusplus
extern "C" {
#endif
/*...*/
#ifdef __cplusplus
}
#endif
#endif /* __INCvxWorksh */
問題分析<a id="orgheadline3"></a>
對于上面問題，顯然，頭文件中的編譯宏 #ifndef __INCvxWorksh 、 #define __INCvxWorksh 、 #endif 的作用是防止該頭文件被重復引用。
那么，
#ifdef __cplusplus
extern "C" {
#endif
和
#ifdef __cplusplus
}
#endif
的作用又是什么呢？我們將在后面對此進行詳細說明。
關于 extern "C"<a id="orgheadline10"></a>
前面的題目中的 __cplusplus 宏，是用來識別編譯器的，也就是說，將當前代碼編譯的時候，是否將代碼作為 C++ 進行編譯。如果是，則定義了 __cplusplus 宏。更多內容，這里就不詳細說明了。
而題目中的 extern "C" 包含雙重含義，從字面上即可得到：首先，被它修飾的目標是 extern 的；其次，被它修飾的目標是 C 的。
具體如下：
被 extern "C" 限定的函數或變量是 extern 類型的。<a id="orgheadline5"></a>
extern 是 C/C++ 語言中表明函數和全局變量作用范圍（可見性）的關鍵字，該關鍵字告訴編譯器，其聲明的函數和變量可以在本模塊或其它模塊中使用。
注意，語句 extern int a; 僅僅是對變量的聲明，其并不是在定義變量 a ，聲明變量并未為 a 分配內存空間。定義語句形式為 int a; ，變量 a 在所有模塊中作為一種全局變量只能被定義一次，否則會出現連接錯誤。
在引用全局變量和函數之前，必須要有這個變量或者函數的聲明（或者定義）。通常，在模塊的頭文件中對本模塊提供給其它模塊引用的函數和全局變量以關鍵字 extern 聲明。例如，如果模塊 B 欲引用該模塊 A 中定義的全局變量和函數時只需包含模塊 A 的頭文件即可。這樣，模塊B中調用模塊 A 中的函數時，在編譯階段，模塊 B 雖然找不到該函數，但是并不會報錯；它會在連接階段中從模塊 A 編譯生成的目標代碼中找到此函數。
與 extern 對應的關鍵字是 static ，被它修飾的全局變量和函數只能在本模塊中使用。因此，一個函數或變量只可能被本模塊使用時，其不可能被 extern "C" 修飾。
被 extern "C" 修飾的變量和函數是按照 C 語言方式編譯和連接的。<a id="orgheadline9"></a>
首先看看 C++ 中，在未加 extern "C" 聲明時，對類似 C 的函數是怎樣編譯的。<a id="orgheadline6"></a>
作為一種面向對象的語言， C++ 支持函數重載，而過程式語言 C 則不支持。所以，函數被 C++ 編譯后在符號庫中的名字與 C 語言的有所不同。例如，假設某個函數的原型為：
void foo( int x, int y );
該函數被 C 編譯器編譯后在符號庫中的名字為 _foo ，而 C++ 編譯器則會產生像 _foo_int_int 之類的名字（不同的編譯器可能生成的名字不同，但是都采用了相同的機制，生成的新名字稱為 mangled name ）。 _foo_int_int 這樣的名字包含了函數名、函數參數數量及類型信息， C++ 就是靠這種機制來實現函數重載的。例如，在 C++ 中，函數 void foo( int x, int y ) 與 void foo( int x, float y ) 編譯生成的符號是不相同的，后者為 _foo_int_float 。
同樣地， C++ 中的變量除支持局部變量外，還支持類成員變量和全局變量。用戶所編寫程序的類成員變量可能與全局變量同名，我們以 . 來區分。而本質上，編譯器在進行編譯時，與函數的處理相似，也為類中的變量取了一個獨一無二的名字，這個名字與用戶程序中同名的全局變量名字不同。
其次，看看在未加 extern "C" 聲明時，是如何連接的。<a id="orgheadline7"></a>
假設在 C++ 中，模塊 A 的頭文件如下：
//模塊A頭文件 moduleA.h
#ifndef MODULE_A_H
#define MODULE_A_H
int foo( int x, int y );
#endif
在模塊 B 中引用該函數：
// 模塊B實現文件 moduleB.cpp
#include "moduleA.h"
foo(2,3);
實際上，在連接階段，連接器會從模塊 A 生成的目標文件 moduleA.obj 中尋找 _foo_int_int 這樣的符號！
對于上面例子，如果 B 模塊是 C 程序，而A模塊是 C++ 庫頭文件的話，會導致鏈接錯誤；同理，如果B模塊是 C++ 程序，而A模塊是C庫的頭文件也會導致錯誤。
再者，看看加 extern "C" 聲明后的編譯和連接方式<a id="orgheadline8"></a>
加 extern "C" 聲明后，模塊 A 的頭文件變為：
// 模塊A頭文件 moduleA.h
#ifndef MODULE_A_H
#define MODULE_A_H
extern "C" int foo( int x, int y );
#endif
在模塊 B 的實現文件中仍然調用 foo( 2,3 ) ，其結果，將會是 C 語言的編譯連接方式：模塊 A 編譯生成 foo 的目標代碼時，沒有對其名字進行特殊處理，采用了 C 語言的方式；連接器在為模塊 B 的目標代碼尋找 foo(2,3) 調用時，尋找的是未經修改的符號名 _foo 。
如果在模塊 A 中函數聲明了 foo 為 extern "C" 類型，而模塊 B 中包含的是 extern int foo( int x, int y ) ，則模塊 B 找不到模塊 A 中的函數(因為這樣的聲明沒有使用 extern "C" 指明采用C語言的編譯鏈接方式)；反之亦然。
所以，綜上可知， extern "C" 這個聲明的真實目的，就是實現 C++ 與 C 及其它語言的混合編程。
用法舉例<a id="orgheadline14"></a>
C++ 引用 C 函數的具體例子<a id="orgheadline11"></a>
在 C++ 中引用 C 語言中的函數和變量，在包含 C 語言頭文件（假設為 cExample.h ）時，需進行下列處理：
extern "C"
{
#include "cExample.h"
}
因為， C 庫的編譯當然是用 C 的方式生成的，其庫中的函數標號一般也是類似前面所說的 _foo 之類的形式，沒有任何參數信息，所以當然在 C++ 中，要指定使用 extern "C" ，進行 C 方式的聲明（如果不指定，那么 C++ 中的默認聲明方式當然是 C++ 方式的，也就是編譯器會產生 _foo_int_int 之類包含參數信息的、 C++ 形式的函數標號，這樣的函數標號在已經編譯好了的、可以直接引用的 C 庫中當然沒有）。通過頭文件對函數進行聲明，再包含頭文件，就能引用到頭文件中聲明的函數(因為函數的實現在庫中呢，所以只聲明，然后鏈接就能用了)。
而在 C 語言中，對其外部函數只能指定為 extern 類型，因為 C 語言中不支持 extern "C" 聲明，在 .c 文件中包含了 extern "C" 時，當然會出現編譯語法錯誤。
下面是一個具體代碼：
/* c語言頭文件：cExample.h */
#ifndef C_EXAMPLE_H
#define C_EXAMPLE_H
extern int add(int x,int y);
#endif
/* c語言實現文件：cExample.c */
#include "cExample.h"
int add( int x, int y )
{
return x + y;
}
// c++實現文件，調用add：cppFile.cpp
extern "C"
{
#include "cExample.h"
}
int main(int argc, char* argv[])
{
add(2,3);
return 0;
}
可見，如果 C++ 調用一個 C 語言編寫的 .DLL 時，在包含 .DLL 的頭文件或聲明接口函數時，應加 extern "C" { } 。這個時候，其實 extern "C" 是在告訴 C++ ，鏈接 C 庫的時候，采用 C 的方式進行鏈接（即尋找類似 _foo 的沒有參數信息的標號，而不是默認的 _foo_int_int 這樣包含了參數信息的 C++ 標號了）。
C 引用 C++ 函數的具體例子<a id="orgheadline12"></a>
在C中引用 C++ 語言中的函數和變量時， C++ 的頭文件需添加 extern "C" ，但是在 C 語言中不能直接引用聲明了 extern "C" 的該頭文件(因為C語言不支持 extern "C" 關鍵字，所以會報編譯錯誤)，應該僅在 C 文件中用 extern 聲明 C++ 中定義的 extern "C" 函數(就是 C++ 中用 extern "C" 聲明的函數，在 C 中用 extern 來聲明一下，這樣 C 就能引用 C++ 的函數了，但是 C 中是不用用 extern "C" 的)。
下面是一個具體代碼：
//C++頭文件 cppExample.h
#ifndef CPP_EXAMPLE_H
#define CPP_EXAMPLE_H
extern "C" int add( int x, int y );
#endif
//C++實現文件 cppExample.cpp
#include "cppExample.h"
int add( int x, int y )
{
return x + y;
}
/* C實現文件 cFile.c
/* 這樣會編譯出錯：#include "cExample.h" */
extern int add( int x, int y );
int main( int argc, char* argv[] )
{
add( 2, 3 );
return 0;
}
上面例子， C 實現文件 cFile.c 不能直接用 #include "cExample.h"= 因為 =C 語言不支持 extern "C" 關鍵字。這個時候，而在 cppExample.h 中使用 extern "C" 修飾的目的是為了讓 C++ 編譯時候能夠生成 C 形式的符號(類似 _foo 不含參數的形式)，然后將其添加到對應的 C++ 實現庫中，以便被 C 程序鏈接到。
對 __BEGIN_DECLS 和 __END_DECLS 的理解<a id="orgheadline13"></a>
在 C 語言代碼中頭文件中，經?？吹匠涑庵旅娴拇a片段：
1. __BEGIN_DECLS
2. .....
3. .....
4. __END_DECLS
其實，這些宏一般都是在標準庫頭文件中定義好了的，例如我當前機器的 sys/cdefs.h 中大致定義如下：
1. #if defined(__cplusplus)
2. #define __BEGIN_DECLS extern "C" {
3. #define __END_DECLS }
4. #else
5. #define __BEGIN_DECLS
6. #define __END_DECLS
7. #endif
這目的當然是擴充 C 語言在編譯的時候，按照 C++ 編譯器進行統一處理，使得 C++ 代碼能夠調用 C 編譯生成的中間代碼。
由于 C 語言的頭文件可能被不同類型的編譯器讀取，因此寫 C 語言的頭文件必須慎重。
總結<a id="orgheadline18"></a>
extern "C" 只是 C++ 的關鍵字，不是 C 的<a id="orgheadline15"></a>
所以，如果在 C 程序中引入了 extern "C" 會導致編譯錯誤。
被 extern "C" 修飾的目標一般是對一個C或者 C++ 函數的聲明<a id="orgheadline16"></a>
從源碼上看 extern "C" 一般對頭文件中函數聲明進行修飾。無論 C 程序中的還是 cpp 中的頭文件，其函數聲明的形式都是一樣的（因為兩者語法基本一樣），對應聲明的實現卻可能由于相應的程序特性而不同了( C 庫和 C++ 庫里面當然會不同)。
extern "C" 這個關鍵字聲明的真實目的，就是實現 C++ 與C及其它語言的混合編程<a id="orgheadline17"></a>
一旦被 extern "C" 修飾之后，它便以 C 的方式工作，可以實現在 C 中引用 C++ 庫的函數，也可以 C++ 中引用 C 庫的函數。
以上，是對 extern "C" 這個關鍵字的理解和總結，如果具體問題想要討論或者發現有何遺漏之處，可以與我聯系。謝謝！
