在專案中融合C和C++有時是不可避免的，在呼叫對方的功能函式的時候，或許會出現這樣那樣的問題，但只要我的C程式碼和我的C++程式碼分別都能成功編譯，那其他就不是問題。近來在主程式是C語言，而呼叫C++功能函式的時候，C++的*.h標頭檔案都能找到，功能函式也都定義了，最重要的是，單獨編譯C++的時候，完全沒有問題，但當用主程式的C呼叫C++的功能函式時，總是提示該函式未定義（undefined），這裡分析問題的出處便是混合調用出現的問題了。
關鍵點在這裡：我們就靠在C++的*.h和*.cpp的頭尾加入下面程式碼才得以解決問題。
#ifdef __cplusplus 
extern "C" { 
#endif 
//一段程式碼 
#ifdef __cplusplus 
} 
#endif 
這樣的程式碼到底是什麼意思呢？首先，__cplusplus是cpp中的自定義巨集，那麼定義了這個巨集的話表示這是一段cpp的程式碼，也就是說，上面的程式碼的含義是:如果這是一段cpp的程式碼，那麼加入extern "C"{和}處理其中的程式碼。 
要明白為何使用extern "C"，還得從cpp中對函式的過載處理開始說起。在c++中，為了支援過載機制，在編譯生成的彙編碼中，要對函式的名字進行一些處理，加入比如函式的返回型別等等.而在C中，只是簡單的函式名字而已，不會加入其他的資訊.也就是說:C++和C對產生的函式名字的處理是不一樣的. 目的就是主要實現C與C++的相互呼叫問題。

c.h的實現
#ifndef _c_h_
#define _c_h_
#ifdef __cplusplus
extern "C" {
#endif
void C_fun();
#ifdef __cplusplus
}
#endif
#endif
-----------------------------------
c.c的實現
＃include "c.h"
void C_fun()
{
}
------------------------------------
在cpp.cpp中呼叫c.c中的C_fun()
cpp.cpp的實現
＃include "c.h"
int main()
{
C_fun()
}
其中__cplusplus是C++編譯器的保留巨集定義．就是說C++編譯器認為這個巨集已經定義了．
所以關鍵是extern "C" {} //這裡告訴你的是__cplusplus不是最重要的，重要的是extern "C" {}
extern "C"是告訴C＋＋編譯器件括號裡的東東是按照C的obj檔案格式編譯的，要連線的話按照C的命名規則去找．
＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
那麼C中是如何呼叫C++中的函式cpp_fun()呢

？這就是最上面我提到的問題，即用C寫主程式，然後呼叫C++功能函式。
因為先有C後有C++, 所以只能從C++的程式碼中考慮了．
加入C++中的函式或變數有可能被C中的檔案呼叫，則應該這樣寫，也是用extern "C"{}
不過是程式碼中要加，標頭檔案也要加，因為可能是C++中也呼叫
--------------------------------------
cpp.h的實現
#ifndef _c_h_
#define _c_h_
#ifdef __cplusplus
extern "C" {
#endif
void CPP_fun();
#ifdef __cplusplus
}
#endif
#endif
.-------------------------------------------
Cpp.cpp的實現
extern "C" { //告訴C+++編譯器,擴號裡按照C的命名規則編譯
void CPP_fun()
{
.....
}
}
C和C++對函式的處理方式是不同的.extern "C"是使C++能夠呼叫C寫作的庫檔案的一個手段，如果要對編譯器提示使用C的方式來處理函式的話，那麼就要使用extern "C"來說明。

在C++ 程式中呼叫被C 編譯器編譯後的函式，為什麼要加extern “C”？
首先，作為extern是C/C++語言中表明函式和全域性變數作用範圍（可見性）的關鍵字，該關鍵字告訴編譯器，其宣告的函式和變數可以在本模組或其它模組中使用。 
通常，在模組的標頭檔案中對本模組提供給其它模組引用的函式和全域性變數以關鍵字extern宣告。例如，如果模組B欲引用該模組A中定義的全域性變數和函式時只需包含模組A的標頭檔案即可。這樣，模組B中呼叫模組A中的函式時，在編譯階段，模組B雖然找不到該函式，但是並不會報錯；它會在連線階段中從模組A編譯生成的目的碼中找到此函式 
extern "C"是連線申明(linkage declaration),被extern "C"修飾的變數和函式是按照C語言方式編譯和連線的,來看看C++中對類似C的函式是怎樣編譯的： 
作為一種面向物件的語言，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"宣告時的連線方式 
假設在C++中，模組A的標頭檔案如下： 
//模組A標頭檔案 moduleA.h 
#ifndef MODULE_A_H 
#define MODULE_A_H 
int foo( int x, int y ); 
#endif 

在模組B中引用該函式： 
//模組B實現檔案 moduleB.cpp 
＃i nclude "moduleA.h" 
foo(2,3); 
實際上，在連線階段，聯結器會從模組A生成的目標檔案moduleA.obj中尋找_foo_int_int這樣的符號！ 
加extern "C"聲明後的編譯和連線方式 
加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 )，其結果是： 
（1）模組A編譯生成foo的目的碼時，沒有對其名字進行特殊處理，採用了C語言的方式； 
（2）聯結器在為模組B的目的碼尋找foo(2,3)呼叫時，尋找的是未經修改的符號名_foo。 
如果在模組A中函式聲明瞭foo為extern "C"型別，而模組B中包含的是extern int foo( int x, int y ) ，則模組B找不到模組A中的函式；反之亦然。 
所以，可以用一句話概括extern “C”這個宣告的真實目的：實現C++與C及其它語言的混合程式設計。 

extern "C"的慣用法 

（1）在C++中引用C語言中的函式和變數，在包含C語言標頭檔案（假設為cExample.h）時，需進行下列處理： 
extern "C" 
{ 
＃i nclude "cExample.h" 
} 
而在C語言的標頭檔案中，對其外部函式只能指定為extern型別，C語言中不支援extern "C"宣告，在.c檔案中包含了extern "C"時會出現編譯語法錯誤。 
C++引用C函式例子工程中包含的三個檔案的原始碼如下： 
/* c語言標頭檔案：cExample.h */ 
#ifndef C_EXAMPLE_H 
#define C_EXAMPLE_H 
extern int add(int x,int y); 
#endif 

/* c語言實現檔案：cExample.c */ 
＃i nclude "cExample.h" 
int add( int x, int y ) 
{ 
return x + y; 
} 

// c++實現檔案，呼叫add：cppFile.cpp 
extern "C" 
{ 
＃i nclude "cExample.h" 
} 
int main(int argc, char* argv[]) 
{ 
add(2,3); 
return 0; 
} 
如果C++呼叫一個C語言編寫的.DLL時，當包括.DLL的標頭檔案或宣告介面函式時，應加extern "C" { }。 
（2）在C中引用C++語言中的函式和變數時，C++的標頭檔案需新增extern "C"，但是在C語言中不能直接引用聲明瞭extern "C"的該標頭檔案，應該僅將C檔案中將C++中定義的extern "C"函式宣告為extern型別。 
C引用C++函式例子工程中包含的三個檔案的原始碼如下： 
//C++標頭檔案 cppExample.h 
#ifndef CPP_EXAMPLE_H 
#define CPP_EXAMPLE_H 
extern "C" int add( int x, int y ); 
#endif 

//C++實現檔案 cppExample.cpp 
＃i nclude "cppExample.h" 
int add( int x, int y ) 
{ 
return x + y; 
} 
/* C實現檔案 cFile.c 
/* 這樣會編譯出錯：＃i nclude "cExample.h" */ 
extern int add( int x, int y ); 
int main( int argc, char* argv[] ) 
{ 
add( 2, 3 ); 
return 0; 
}

C 函式中呼叫 C++函式

舉例：
// cpp.h
#ifndef __cpp_h__
#define __cpp_h__
class class1 {
class1();
~class1();
public:
int I;
int J;
int getI(void);
};
#endif
// end file

// cpp.cpp
＃i nclude "stdafx.h"
＃i nclude <iostream>
＃i nclude "cpp.h"
＃i nclude "c.h"
using namespace std; // 開啟標準庫名字空間
class1::class1()
{}
class1::~class1()
{}
int class1::getI(void)
{
return I++;
}

// 按 C 呼叫方式編譯下面函式
extern "C"
int get_class1_I(struct1 * p)
{
class1 * pClass1 = (class1 *)p;
cout << "c++: " << pClass1->getI() << endl;
return pClass1->getI();
}
// end file

// c.h
#ifndef __c_h__
#define __c_h__
#ifdef __cplusplus
extern "C" {
#endif
typedef struct {
int i; // 與 class1 類中變數一致
int j;
}struct1;
#ifdef __cplusplus
}
#endif
#endif
// end file

// c.c
＃i nclude <cstdio>
＃i nclude "c.h"
extern int get_class1_I(void * p);
struct1 s;
int main(void)
{
printf ("c: %d\n", get_class1_I(&s));
printf ("c: %d\n", get_class1_I(&s));

return 0;
}
// end file

本例在ADS 1.2中編譯通過，執行結果正確。
VC++中編譯時，C.C檔案編譯選項中選擇 Not using precompile headers。

C中如何呼叫C++函式、類內函式

在C中如何呼叫C++函式的問題，簡單回答是將函式用extern "C"宣告，當被問及如何將類內成員函式宣告時，一時語塞，後來網上查了下，網上有一翻譯C++之父的文章可以作為解答，遂拿來Mark一下。
該翻譯的文件Bjarne Stroustrup的原文連結地址是 http://www.research.att.com/~bs/bs_faq2.html#callCpp

Linux C呼叫C++庫 
轉自：http://blog.linuxgem.org/tzc/show/551.html

呼叫C++函式庫，一般不能直接呼叫，需要將C++庫轉換成C介面輸出，方可以使用C呼叫
將 C++ 函式宣告為``extern "C"''（在你的 C++ 程式碼裡做這個宣告），然後呼叫它（在你的 C 或者 C++ 程式碼裡呼叫）。例如：
// C++ code:
extern "C" void f(int); 
void f(int i)
{
// ...
} 

然後，你可以這樣使用 f()： 
/* C code: */
void f(int); 
void cc(int i)
{
f(i);
/* ... */
}

當然，這招只適用於非成員函式。如果你想要在 C 裡呼叫成員函式（包括虛擬函式），則需要提供一個簡單的包裝（wrapper）。例如：
// C++ code:
class C
{
// ...
virtual double f(int);
}; 

extern "C" double call_C_f(C* p, int i) // wrapper function
{
return p->f(i);
}

然後，你就可以這樣呼叫 C::f()： 
/* C code: */
double call_C_f(struct C* p, int i); 

void ccc(struct C* p, int i)
{
double d = call_C_f(p,i);
/* ... */
} 

如果你想在 C 裡呼叫過載函式，則必須提供不同名字的包裝，這樣才能被 C 程式碼呼叫。例如：
// C++ code:
void f(int);
void f(double); 

extern "C" void f_i(int i) { f(i); }
extern "C" void f_d(double d) { f(d); } 

然後，你可以這樣使用每個過載的 f()： 
/* C code: */

void f_i(int);
void f_d(double); 

void cccc(int i,double d)
{
f_i(i);
f_d(d);
/* ... */
} 
注意，這些技巧也適用於在 C 裡呼叫 C++ 類庫，即使你不能（或者不想）修改 C++ 標頭檔案。

再看下面的例子：
• aa.cxx
#include "aa.h"
int sample::method()
{
cout<<"method is called!\n";
}
• aa.h
#include <iostream>
using namespace std;
class sample
{
public:
int method();
};
將上面的兩個檔案生成動態庫libaa.so放到 /usr/lib目錄下，編譯命令如下
sudo g++ -fpic -shared -g -o /usr/lib/libaa.so aa.cxx -I ./

由於在C中不能識別類，所以要將上面類的成員函式封裝成C介面函式輸出，下面進行封裝，將輸出介面轉換成C介面。
• mylib.cxx
#include "add.h"
#ifndef _cplusplus
#define _cplusplus
#include "mylib.h"
#endif

int myfunc()
{
sample ss;
ss.method();
return 0;
}
• mylib.h
#ifdef _cplusplus
extern "C"
{
#endif

int myfunc();

#ifdef _cplusplus
}
#endif
在 linux下，gcc編譯器並沒用變數_cplusplus來區分是C程式碼還是C++程式碼，如果使用gcc編譯器，這裡我們可以自己定義一個變數 _cplusplus用於區分C和C++程式碼，所以在mylib.cxx中定義了一個變數_cplusplus用於識別是否需要“extern "C"”將函式介面封裝成C介面。但是如果使用g++編譯器則不需要專門定義_cplusplus，編譯命令如下：
g++ -fpic -shared -g -o mylib.so mylib.cxx -la -I ./

• main.c
#include <stdio.h>
#include <dlfcn.h>
#include "mylib.h"
int
main()
{
int (*dlfunc)();
void *handle; //定義一個控制代碼
handle = dlopen("./mylib.so", RTLD_LAZY);//獲得庫控制代碼
dlfunc = dlsym(handle, "myfunc"); //獲得函式入口
(*dlfunc)();
dlclose(handle);

return 0;
}
編譯命令如下：
gcc -o main main.c ./mylib.so -ldl
下面就可以執行了。
需要說明的是，由於main.c 和 mylib.cxx都需要包含mylib.h，並且要將函式myfunc封裝成C介面函式輸出需要“extern "C"”，而C又不識別“extern "C"”，所以需要定義_cplusplus來區別處理mylib.h中的函式myfunc。
在main.c的main函式中直接呼叫myfunc（）函式也能執行，這裡介紹的是常規呼叫庫函式的方法。

面試題為什麼標準標頭檔案都有類似以下的結構？ 
#ifndef __INCvxWorksh 
#define __INCvxWorksh 
#ifdef __cplusplus 
extern "C"{ 
#endif 
#ifdef __cplusplus 
} #endif #endif

分析 
顯然，標頭檔案中的編譯巨集“#ifndef __INCvxWorksh、#define __INCvxWorksh、#endif” 的作用是防止該標頭檔案被重複引用。
那麼
#ifdef __cplusplus
extern "C" {
#endif 
#ifdef __cplusplus
}
#endif 的作用又是什麼呢？
深層揭密extern "C"
extern "C" 包含雙重含義，從字面上即可得到：首先，被它修飾的目標是“extern”的；其次，被它修飾的目標是“C”的。讓我們來詳細解讀這兩重含義。
被extern "C"限定的函式或變數是extern型別的；
extern是C/C++語言中表明函式和全域性變數作用範圍（可見性）的關鍵字，該關鍵字告訴編譯器，其宣告的函式和變數可以在本模組或其它模組中使用。記住，下列語句： extern int a;
僅僅是一個變數的宣告，其並不是在定義變數a，並未為a分配記憶體空間。變數a在所有模組中作為一種全域性變數只能被定義一次，否則會出現連線錯誤。

通常，在模組的標頭檔案中對本模組提供給其它模組引用的函式和全域性變數以關鍵字extern宣告。例如，如果模組B欲引用該模組A中定義的全域性變數和函 數時只需包含模組A的標頭檔案即可。這樣，模組B中呼叫模組A中的函式時，在編譯階段，模組B雖然找不到該函式，但是並不會報錯；它會在連線階段中從模組A 編譯生成的目的碼中找到此函式。
與extern對應的關鍵字是static，被它修飾的全域性變數和函式只能在本模組中使用。因此，一個函式或變數只可能被本模組使用時，其不可能被extern “C”修飾。
被extern "C"修飾的變數和函式是按照C語言方式編譯和連線的；

未加extern “C”宣告時的編譯方式
首先看看C++中對類似C的函式是怎樣編譯的。
作為一種面向物件的語言，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"宣告時的連線方式
假設在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這樣的符號！

加extern "C"聲明後的編譯和連線方式
加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 )，其結果是：
（1）模組A編譯生成foo的目的碼時，沒有對其名字進行特殊處理，採用了C語言的方式；
（2）聯結器在為模組B的目的碼尋找foo(2,3)呼叫時，尋找的是未經修改的符號名_foo。
如果在模組A中函式聲明瞭foo為extern "C"型別，而模組B中包含的是extern int foo( int x, int y ) ，則模組B找不到模組A中的函式；反之亦然。
所以，可以用一句話概括extern “C”這個宣告的真實目的（任何語言中的任何語法特性的誕生都不是隨意而為的，來源於真實世界的需求驅動。我們在思考問題時，不能只停留在這個語言是怎麼做的，還要問一問它為什麼要這麼做，動機是什麼，這樣我們可以更深入地理解許多問題）：
實現C++與C及其它語言的混合程式設計。
明白了C++中extern "C"的設立動機，我們下面來具體分析extern "C"通常的使用技巧。

extern "C"的慣用法
（1）在C++中引用C語言中的函式和變數，在包含C語言標頭檔案（假設為cExample.h）時，需進行下列處理：
extern "C"
{
#include "cExample.h" 
}
而在C語言的標頭檔案中，對其外部函式只能指定為extern型別，C語言中不支援extern "C"宣告，在.c檔案中包含了extern "C"時會出現編譯語法錯誤。
筆者編寫的C++引用C函式例子工程中包含的三個檔案的原始碼如下：

#ifndef C_EXAMPLE_H
#define C_EXAMPLE_H
extern int add(int x,int y);
#endif 
#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" {　}
　 （2）在C中引用C++語言中的函式和變數時，C++的標頭檔案需新增extern "C"，但是在C語言中不能直接引用聲明瞭extern "C"的該標頭檔案，應該僅在C檔案中將C++中定義的extern "C"函式宣告為extern型別。
筆者編寫的C引用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;
}

extern int add( int x, int y );
int main( int argc, char* argv[] )
{
add( 2, 3 ); 
return 0;
}