【導讀】：本文詳細解析extern "C"的底層原理與實際應用。
以下是正文
在你工作過的系統裡，不知能否看到類似下面的程式碼。
這好像沒有什麼問題，你應該還會想：“嗯⋯是啊，我們的程式碼都是這樣寫的，從來沒有因此碰到過什麼麻煩啊～”。
你說的沒錯，如果你的標頭檔案從來沒有被任何C++程式引用過的話。
這與C++有什麼關係呢? 看看__cplusplus（注意前面是兩個下劃線） 的名字你就應該知道它與C++有很大關係。__cplusplus是一個C++規範規定的預定義宏。你可以信任的是：所有的現代C++編譯器都預先定義了它；而所有C語言編譯器則不會。另外，按照規範__cplusplus的值應該等於1 9 9 7 1 1 L ，然而不是所有的編譯器都照此實現，比如g++編譯器就將它的值定義為1。
所以，如果上述程式碼被C語言程式引用的話，它的內容就等價於下列程式碼。
在這種情況下，既然extern "C" { }經過預處理之後根本就不存在，那麼它和#include指令之間的關係問題自然也就是無中生有。
extern "C"的前世今生
在C++編譯器裡，有一位暗黑破壞神，專門從事一份稱作“名字粉碎”(name mangling)的工作。當把一個C++的原始檔投入編譯的時候，它就開始工作，把每一個它在原始檔裡看到的外部可見的名字粉碎的面目全非，然後儲存到二進位制目標檔案的符號表裡。
之所以在C++的世界裡存在這樣一個怪物，是因為C++允許對一個名字給予不同的定義，只要在語義上沒有二義性就好。比如，你可以讓兩個函式是同名的，只要它們的引數列表不同即可，這就是函式過載(function overloading)；甚至，你可以讓兩個函式的原型宣告是完全相同的，只要它們所處的名字空間(namespace)不一樣即可。事實上，當處於不同的名字空間時，所有的名字都是可以重複的，無論是函式名，變數名，還是型別名。
另外，C++程式的構造方式仍然繼承了C語言的傳統：編譯器把每一個透過命令列指定的原始碼檔案看做一個獨立的編譯單元，生成目標檔案；然後，連結器透過查詢這些目標檔案的符號表將它們連結在一起生成可執行程式。
編譯和連結是兩個階段的事情；事實上，編譯器和連結器是兩個完全獨立的工具。編譯器可以透過語義分析知道那些同名的符號之間的差別；而連結器卻只能透過目標檔案符號表中儲存的名字來識別物件。
所以，編譯器進行名字粉碎的目的是為了讓連結器在工作的時候不陷入困惑，將所有名字重新編碼，生成全域性唯一，不重複的新名字，讓連結器能夠準確識別每個名字所對應的物件。
但 C語言卻是一門單一名字空間的語言，也不允許函式過載，也就是說，在一個編譯和連結的範圍之內，C語言不允許存在同名物件。比如，在一個編譯單元內部，不允許存在同名的函式，無論這個函式是否用static修飾；在一個可執行程式對應的所有目標檔案裡，不允許存在同名物件，無論它代表一個全域性變數，還是一個函式。所以，C語言編譯器不需要對任何名字進行復雜的處理（或者僅僅對名字進行簡單一致的修飾（decoration），比如在名字前面統一的加上單下劃線_）。
C++的締造者Bjarne Stroustrup在最初就把——能夠相容C，能夠複用大量已經存在的C庫——列為C++語言的重要目標。但兩種語言的編譯器對待名字的處理方式是不一致的，這就給連結過程帶來了麻煩。
例如，現有一個名為my_handle.h的標頭檔案，內容如下：
然後使用C語言編譯器編譯my_handle.c，生成目標檔案my_handle.o。由於C語言編譯器不對名字進行粉碎，所以在my_handle.o的符號表裡，這三個函式的名字和原始碼檔案中的宣告是一致的。
隨後，我們想讓一個C++程式呼叫這些函式，所以，它也包含了標頭檔案my_handle.h。假設這個C++原始碼檔案的名字叫my_handle_client.cpp，其內容如下：
其中，粗體的部分就是那三個函式的名字被粉碎後的樣子。
然後，為了讓程式可以工作，你必須將my_handle.o和my_handle_client.o放在一起連結。由於在兩個目標檔案對於同一物件的命名不一樣，連結器將報告相關的“符號未定義”錯誤。
為了解決這一問題，C++引入了連結規範(linkage specification)的概念，表示法為extern"language string"，C++編譯器普遍支援的"language string"有"C"和"C++"，分別對應C語言和C++語言。
連結規範的作用是告訴C++編譯：對於所有使用了連結規範進行修飾的宣告或定義，應該按照指定語言的方式來處理，比如名字，呼叫習慣（calling convention）等等。
連結規範的用法有兩種：
1.單個宣告的連結規範，比如：
extern "C" void foo();2. 一組宣告的連結規範，比如：
extern "C"{ void foo(); int bar();}對我們之前的例子而言，如果我們把標頭檔案my_handle.h的內容改成：
然後使用C++編譯器重新編譯my_handle_client.cpp，所生成目標檔案my_handle_client.o中的符號表就變為：
從中我們可以看出，此時，用extern "C" 修飾了的宣告，其生成的符號和C語言編譯器生成的符號保持了一致。這樣，當你再次把my_handle.o和my_handle_client.o放在一起連結的時候，就不會再有之前的“符號未定義”錯誤了。
小心門後的未知世界
在我們清楚了 extern "C" 的來歷和用途之後，回到我們本來的話題上，為什麼不能把#include 指令放置在 extern "C" { ... } 裡面？
我們先來看一個例子，現有a.h，b.h，c.h以及foo.cpp，其中foo.cpp包含c.h，c.h包含b.h，b.h包含a.h，如下：
現使用C++編譯器的預處理選項來編譯foo.cpp，得到下面的結果：
正如你看到的，當你把#include指令放置在extern "C" { }裡的時候，則會造成extern "C" { } 的巢狀。這種巢狀是被C++規範允許的。當巢狀發生時，以最內層的巢狀為準。比如在下面程式碼中，函式foo會使用C++的連結規範，而函式bar則會使用C的連結規範。
如果能夠保證一個C語言標頭檔案直接或間接依賴的所有標頭檔案也都是C語言的，那麼按照C++語言規範，這種巢狀應該不會有什麼問題。但具體到某些編譯器的實現，比如MSVC2005，卻可能由於 extern "C" { } 的巢狀過深而報告錯誤。不要因此而責備微軟，因為就這個問題而言，這種巢狀是毫無意義的。你完全可以透過把#include指令放置在extern "C" { }的外面來避免巢狀。拿之前的例子來說，如果我們把各個標頭檔案的 #include 指令都移到extern "C" { } 之外，然後使用C++編譯器的預處理選項來編譯foo.cpp，就會得到下面的結果：
這樣的結果肯定不會引起編譯問題的結果——即便是使用MSVC。
把 #include 指令放置在extern "C" { }裡面的另外一個重大風險是，你可能會無意中改變一個函式宣告的連結規範。比如：有兩個標頭檔案a.h，b.h，其中b.h包含a.h，如下：
按照a.h作者的本意，函式foo是一個C++自由函式，其連結規範為"C++"。但在b.h中，由於#include "a.h"被放到了extern "C" { }的內部，函式foo的連結規範被不正確地更改了。
由於每一條 #include 指令後面都隱藏這一個未知的世界，除非你刻意去探索，否則你永遠都不知道，當你把一條條#include指令放置於extern "C" { }裡面的時候，到底會產生怎樣的結果，會帶來何種的風險。或許你會說，“我可以去檢視這些被包含的標頭檔案，我可以保證它們不會帶來麻煩”。但，何必呢？畢竟，我們完全可以不必為不必要的事情買單，不是嗎？
Q&A
Q: 難道任何# i n c l u d e指令都不能放在e x t e r n "C"裡面嗎？
A: 正像這個世界的大多數規則一樣，總會存在特殊情況。
有時候，你可能利用標頭檔案機制“巧妙”的解決一些問題。比如，#pragma pack的問題。這些標頭檔案和常規的標頭檔案作用是不一樣的，它們裡面不會放置C的函式宣告或者變數定義，連結規範不會對它們的內容產生影響。這種情況下，你可以不必遵守這些規則。
更加一般的原則是，在你明白了這所有的原理之後，只要你明白自己在幹什麼，那就去做吧。
Q: 你只說了不應該放入e x t e r n "C"的，但什麼可以放入呢？
A: 連結規範僅僅用於修飾函式和變數，以及函式型別。所以，嚴格的講，你只應該把這三種物件放置於extern "C"的內部。
但，你把C語言的其它元素，比如非函式型別定義（結構體，列舉等）放入extern "C"內部，也不會帶來任何影響。更不用說宏定義預處理指令了。
所以，如果你更加看重良好組織和管理的習慣，你應該只在必須使用extern "C"宣告的地方使用它。即使你比較懶惰，絕大多數情況下，把一個頭件自身的所有定義和宣告都放置在extern"C"裡面也不會有太大的問題。
Q: 如果一個帶有函式/變數宣告的C標頭檔案裡沒有e x t e r n "C"宣告怎麼辦？
A: 如果你可以判斷，這個標頭檔案永遠不可能讓C++程式碼來使用，那麼就不要管它。
但現實是，大多數情況下，你無法準確的推測未來。你在現在就加上這個extern "C"，這花不了你多少成本，但如果你現在沒有加，等到將來這個標頭檔案無意中被別人的C++程式包含的時候，別人很可能需要更高的成本來定位錯誤和修復問題。
Q: 如果我的C+ +程式想包含一個C標頭檔案a . h，它的內容包含了C的函式/變數宣告，但它們卻沒有使用e x t e r n "C"連結規範，該怎麼辦？
A: 在a.h裡面加上它。
某些人可能會建議你，如果a.h沒有extern "C"，而b.cpp包含了a.h，可以在b.cpp里加上 ：
extern "C"{ #include "a.h"}這是一個邪惡的方案，原因在之前我們已經闡述。但值得探討的是，這種方案這背後卻可能隱含著一個假設，即我們不能修改a.h。不能修改的原因可能來自兩個方面：
1. 標頭檔案程式碼屬於其它團隊或者第三方公司，你沒有修改程式碼的許可權；
2. 雖然你擁有修改程式碼的許可權，但由於這個標頭檔案屬於遺留系統，冒然修改可能會帶來不可預知的問題。
對 於第一種情況，不要試圖自己進行workaround，因為這會給你帶來不必要的麻煩。正確的解決方案是，把它當作一個bug，傳送缺陷報告給相應的團隊 或第三方公司。如果是自己公司的團隊或你已經付費的第三方公司，他們有義務為你進行這樣的修改。如果他們不明白這件事情的重要性，告訴他們。如果這些頭文 件屬於一個免費開源軟體，自己進行正確的修改，併發布patch給其開發團隊。
在 第二種情況下，你需要拋棄掉這種不必要的安全意識。因為，首先，對於大多數標頭檔案而言，這種修改都不是一種複雜的，高風險的修改，一切都在可控的範圍之 內；其次，如果某個標頭檔案混亂而複雜，雖然對於遺留系統的哲學應該是：“在它還沒有帶來麻煩之前不要動它”，但現在麻煩已經來了，逃避不如正視，所以上策 是，將其視作一個可以整理到乾淨合理狀態的良好機會。
Q: 我們程式碼中關於e x t e r n "C"的寫法如下，這正確嗎?
A: 不確定。
按照C++的規範定義，__cplusplus 的值應該被定義為199711L，這是一個非零的值；儘管某些編譯器並沒有按照規範來實現，但仍然能夠保證__cplusplus的值為非零——至少我到目前為止還沒有看到哪款編譯器將其實現為0。這種情況下，#if __cplusplus ... #endif完全是冗餘的。
但，C++編譯器的廠商是如此之多，沒有人可以保證某款編譯器，或某款編譯器的早期版本沒有將__cplusplus的值定義為0。但即便如此，只要能夠保證宏__cplusplus只在C++編譯器中被預先定義 ，那麼，僅僅使用#ifdef __cplusplus ⋯ #endif就足以確保意圖的正確性；額外的使用#if __cplusplus ... #endif反而是錯誤的。
只有在這種情況下：即某個廠商的C語言和C++語言編譯器都預先定義了__cplusplus ，但透過其值為0和非零來進行區分，使用#if __cplusplus ... #endif才是正確且必要的。
既然現實世界是如此複雜，你就需要明確自己的目標，然後根據目標定義相應的策略。比如：如果你的目標是讓你的程式碼能夠使用幾款主流的、正確遵守了規範的編譯器進行編譯，那麼你只需要簡單的使用#ifdef __cplusplus ... #endif就足夠了。
但如果你的產品是一個雄心勃勃的，試圖相容各種編譯器的（包括未知的）跨平臺產品， 我們可能不得不使用下述方法來應對各種情況 ，其中__ALIEN_C_LINKAGE__是為了標識那些在C和C++編譯中都定義了__cplusplus宏的編譯器。
這應該可以工作，但在每個標頭檔案中都寫這麼一大串，不僅有礙觀瞻，還會造成一旦策略進行修改，就會到處修改的狀況。違反了DRY(Don't Repeat Yourself)原則，你總要為之付出額外的代價。解決它的一個簡單方案是，定義一個特定的標頭檔案——比如clinkage.h，在其中增加這樣的定義：
以下舉例中c的函式宣告和定義分別在cfun.h 和 cfun.c 中，函式列印字串 “this is c fun call”，c++函式宣告和定義分別在cppfun.h 和 cppfun.cpp中，函式列印字串 "this is cpp fun call", 編譯環境vc2010
c++ 呼叫 c 的方法（關鍵是要讓c的函式按照c的方式編譯，而不是c++的方式）
（1） cfun.h如下：
#ifndef _C_FUN_H_#define _C_FUN_H_ void cfun();#endifcppfun.cpp 如下：
//#include "cfun.h" 不需要包含cfun.h#include "cppfun.h"#include <iostream>using namespace std;extern "C" void cfun(); //宣告為 extern void cfun(); 錯誤void cppfun(){ cout<<"this is cpp fun call"<<endl;}int main(){ cfun(); return 0;}（2）cfun.h同上
cppfun.cpp 如下：
extern "C"{ #include "cfun.h"//注意include語句一定要單獨佔一行;}#include "cppfun.h"#include <iostream>using namespace std;void cppfun(){ cout<<"this is cpp fun call"<<endl;}int main(){ cfun(); return 0;}（3）cfun.h如下：
#ifndef _C_FUN_H_#define _C_FUN_H_#ifdef __cplusplusextern "C"{#endif void cfun();#ifdef __cplusplus}#endif#endifcppfun.cpp如下：
#include "cfun.h"#include "cppfun.h"#include <iostream>using namespace std;void cppfun(){ cout<<"this is cpp fun call"<<endl;}int main(){ cfun(); return 0;}c呼叫c++（關鍵是C++ 提供一個符合 C 呼叫慣例的函式）
在vs2010上測試時，沒有宣告什麼extern等，只在在cfun.c中包含cppfun.h，然後呼叫cppfun()也可以編譯執行，在gcc下就編譯出錯，按照c++/c的標準這種做法應該是錯誤的。以下方法兩種編譯器都可以執行
cppfun.h如下：
#ifndef _CPP_FUN_H_#define _CPP_FUN_H_extern "C" void cppfun();#endifcfun.c如下：
//#include "cppfun.h" //不要包含標頭檔案，否則編譯出錯#include "cfun.h"#include <stdio.h>void cfun(){ printf("this is c fun call\n");}extern void cppfun();int main(){#ifdef __cplusplus cfun();#endif cppfun(); return 0;}https://www.cnblogs.com/TenosDoIt/p/3163621.html