extern c 解析

小東邪發表於2018-03-25

背景

在很多專案中我們常看到這樣的程式碼

#ifdef __cplusplus
extern "C" {
#endif
 
/*...*/
 
#ifdef __cplusplus
}
#endif
複製程式碼

但是它到底有什麼用呢？下面我們來介紹這樣的用法。

流程

1. #ifdef _cplusplus / #endif _cplusplus

  • #ifdef/#endif、#ifndef/#endif用於條件編譯,表示如果(ifndef ：沒有)定義了巨集_cplusplus,就執行它們之間的語句，否則不執行
  • 那麼我們為什麼需要#ifdef _cplusplus/#endif _cplusplus呢？因為C語言中不支援extern "C"的宣告，所以如果在.c檔案中包含了extern "C"時，編譯出錯，所以我們需要用條件編譯來避免。

舉個例子

// xdx.h

#ifndef XDX
#define    XDX
 
#ifdef __cplusplus
extern "C" {
#endif /* __cplusplus */
 
/*.................................
 * do something here
 *.................................
 */
 
#ifdef __cplusplus
}
#endif /* __cplusplus */
 
#endif /* XDX */
複製程式碼

如何說明上面巨集#ifndef/#endif的作用？

  • 這個標頭檔案xdx.h可能再專案中被多個原始檔包含(#include "xdx.h",而對於一個大型專案來說，這些冗餘可能導致錯誤，因為一個標頭檔案包含類定義或inline函式，在一個原始檔中xdx.h可能會被#include兩次(如a.h中包含xdx.h,而b.c中#include a.h 和 xdx.h)，這就會出錯(在同一個原始檔中一個結構體，類被定義了兩次)
  • 從邏輯觀點和減少編譯時間上，都要求取出這些冗餘。但有時我們需要這種冗餘來保證各個模組的獨立性。

所以下面的程式碼就是為了解決這個問題

#ifndef xdx 
#define    xdx 
/*……………………………*/ 
#endif /* xdx */
複製程式碼

如果定義了xdx,#ifndef / #endif之間的內容就被忽略掉。因此，編譯時第一次看到xdx.h，它的內容會被讀取且給定xdx這個值，之後再次看到xdx.h標頭檔案時，xdx已經被定義，xdx.h的內容就不會再次被讀取了。

2. extern "C"

2 - 1 .extern 關鍵字

專案中必須保證函式，變數，列舉等在所有原始檔中保持一致，除非你指定定義為區域性的。

//file1.c:
    int x=1;
    int f(){do something here}
//file2.c:
    extern int x;
    int f();
    void g(){x=f();}

複製程式碼

在file2.c中g()使用的x和f()是定義在file1.c中的。extern關鍵字表明file2.c中x，僅僅是一個變數的宣告，其並不是在定義變數x，並未為x分配記憶體空間。變數x在所有模組中作為一種全域性變數只能被定義一次，否則會出現連線錯誤。但是可以宣告多次，且宣告必須保證型別一致，如：

//file1.c:
    int x=1;
    int b=1;
    extern c;
//file2.c:
    int x;// x equals to default of int type 0
    int f();
    extern double b;
    extern int c;
複製程式碼

在這段程式碼中存在著這樣的三個錯誤：

  • x被定義了兩次
  • b兩次被宣告為不同的型別
  • c被宣告瞭兩次，但卻沒有定義

回到extern關鍵字，extern是C/C++語言中表明函式和全域性變數作用範圍（可見性）的關鍵字，該關鍵字告訴編譯器，其宣告的函式和變數可以在本模組或其它模組中使用。通常，在模組的標頭檔案中對本模組提供給其它模組引用的函式和全域性變數以關鍵字extern宣告。例如，如果模組B欲引用該模組A中定義的全域性變數和函式時只需包含模組A的標頭檔案即可。這樣，模組B中呼叫模組A中的函式時，在編譯階段，模組B雖然找不到該函式，但是並不會報錯；它會在連線階段中從模組A編譯生成的目的碼中找到此函式。

與extern對應的關鍵字是 static，被它修飾的全域性變數和函式只能在本模組中使用。因此，一個函式或變數只可能被本模組使用時，其不可能被extern “C”修飾。

2 - 2. "C" 典型的，一個C++ 程式包含其它語言編寫的部分程式碼。類似的，C++編寫的程式碼片段可能被使用在其它語言編寫的程式碼中。不同語言編寫的程式碼互相呼叫是困難的，甚至是同一種編寫的程式碼但不同的編譯器編譯的程式碼。例如，不同語言和同種語言的不同實現可能會在註冊變數保持引數和引數在棧上的佈局，這個方面不一樣。

為了使它們遵守統一規則，可以使用extern指定一個編譯和連線規約。例如，宣告C和C++標準庫函式strcyp()，並指定它應該根據C的編譯和連線規約來連結：

extern "C" char* strcpy(char*,const char*);

注意它與下面的宣告的不同之處：

extern char* strcpy(char*,const char*);

下面的這個宣告僅表示在連線的時候呼叫strcpy()。

  • extern "C"指令非常有用，因為C和C++的近親關係。

注意：extern "C"指令中的C，表示的一種編譯和連線規約，而不是一種語言。C表示符合C語言的編譯和連線規約的任何語言，如Fortran、assembler等。

  • extern "C"指令僅指定編譯和連線規約，但不影響語義。例如在函式宣告中，指定了extern "C"，仍然要遵守C++的型別檢測、引數轉換規則。
  • 為了宣告一個變數而不是定義一個變數，你必須在宣告時指定extern關鍵字，但是當你又加上了"C"，它不會改變語義，但是會改變它的編譯和連線方式。

2 - 2. 小結extern "C"

  • extern "C"的真實目的是實現類C和C++的混合程式設計

在C++ 原始檔中的語句前面加上extern "C"，表明它按照類C的編譯和連線規約來編譯和連線，而不是C++ 的編譯的連線規約。這樣在類C的程式碼中就可以呼叫C++的函式or變數等。（注：我在這裡所說的類C，代表的是跟C語言的編譯和連線方式一致的所有語言）

3.C和C++互相呼叫

首先要明白C和C++互相呼叫，你得知道它們之間的編譯和連線差異，及如何利用extern "C"來實現相互呼叫。

3 - 1. C++的編譯和連線

C++ 是一個面嚮物件語言（雖不是純粹的面嚮物件語言），它支援函式的過載，過載這個特性給我們帶來了很大的便利。為了支援函式過載的這個特性，C++ 編譯器實際上將下面這些過載函式：

void print(int i);
void print(char c);
void print(float f);
void print(char* s);
複製程式碼

編譯為：

_print_int
_print_char
_print_float
_pirnt_string
複製程式碼

這樣的函式名，來唯一標識每個函式。注：不同的編譯器實現可能不一樣，但是都是利用這種機制。所以當連線是呼叫print(3)時，它會去查詢_print_int(3)這樣的函式。下面說個題外話，正是因為這點，過載被認為不是多型，多型是執行時動態繫結（“一種介面多種實現”），如果硬要認為過載是多型，它頂多是編譯時“多型”。

C++ 中的變數，編譯也類似，如全域性變數可能編譯g_xx，類變數編譯為c_xx等。連線是也是按照這種機制去查詢相應的變數。

3 - 2. C的編譯和連線

C語言中並沒有過載和類這些特性，故並不像C++ 那樣print(int i)，會被編譯為 _print_int，而是直接編譯為_print等。因此如果直接在C++中呼叫C的函式會失敗，因為連線是呼叫C中的print(3)時，它會去找_print_int(3)。因此extern "C"的作用就體現出來

3 - 3. C++中呼叫C的程式碼

假設一個C的標頭檔案cHeader.h中包含一個函式print(int i)，為了在C++中能夠呼叫它，必須要加上extern關鍵字（原因在extern關鍵字那節已經介紹）。它的程式碼如下：

#ifndef C_HEADER
#define C_HEADER
 
extern void print(int i);
 
#endif C_HEADER
複製程式碼

相對應的實現檔案為cHeader.c的程式碼為：

#include <stdio.h>
#include "cHeader.h"
void print(int i)
{
    printf("cHeader %d\n",i);
}
複製程式碼

現在C++ 的程式碼檔案C++.cpp中引用C中的print(int i)函式：

extern "C"{
#include "cHeader.h"
}
 
int main(int argc,char** argv)
{
    print(3);
    return 0;
}
複製程式碼

3 - 3. C中呼叫C++的程式碼

現在換成在C中呼叫C++ 的程式碼，這與在C++ 中呼叫C的程式碼有所不同。如下在cppHeader.h標頭檔案中定義了下面的程式碼：

#ifndef CPP_HEADER
#define CPP_HEADER
 
extern "C" void print(int i);
 
#endif CPP_HEADER
複製程式碼

相應的實現檔案cppHeader.cpp檔案中程式碼如下：

#include "cppHeader.h"
 
#include <iostream>
using namespace std;
void print(int i)
{
    cout<<"cppHeader "<<i<<endl;
}
複製程式碼

在C的程式碼檔案c.c中呼叫print函式：

extern void print(int i);
int main(int argc,char** argv)
{
    print(3);
    return 0;
}
複製程式碼

注意在C的程式碼檔案中直接#include "cppHeader.h"標頭檔案，編譯出錯。而且如果不加extern int print(int i)編譯也會出錯。

4. C和C++混合呼叫特別之處函式指標

當我們C和C++ 混合程式設計時，有時候會用一種語言定義函式指標，而在應用中將函式指標指向另一中語言定義的函式。如果C和C++ 共享同一中編譯和連線、函式呼叫機制，這樣做是可以的。然而，這樣的通用機制，通常不然假定它存在，因此我們必須小心地確保函式以期望的方式呼叫。

而且當指定一個函式指標的編譯和連線方式時，函式的所有型別，包括函式名、函式引入的變數也按照指定的方式編譯和連線。如下例：

typedef int (*FT) (const void* ,const void*);//style of C++
 
extern "C"{
    typedef int (*CFT) (const void*,const void*);//style of C
    void qsort(void* p,size_t n,size_t sz,CFT cmp);//style of C
}
 
void isort(void* p,size_t n,size_t sz,FT cmp);//style of C++
void xsort(void* p,size_t n,size_t sz,CFT cmp);//style of C
 
//style of C
extern "C" void ysort(void* p,size_t n,size_t sz,FT cmp);
 
int compare(const void*,const void*);//style of C++
extern "C" ccomp(const void*,const void*);//style of C
 
void f(char* v,int sz)
{
    //error,as qsort is style of C
    //but compare is style of C++
    qsort(v,sz,1,&compare);
    qsort(v,sz,1,&ccomp);//ok
     
    isort(v,sz,1,&compare);//ok
    //error,as isort is style of C++
    //but ccomp is style of C
    isort(v,sz,1,&ccopm);
}
複製程式碼

注意：typedef int (* FT) (const void* ,const void*)，表示定義了一個函式指標的別名FT，這種函式指標指向的函式有這樣的特徵：返回值為int型、有兩個引數，引數型別可以為任意型別的指標（因為為void*）。

最典型的函式指標的別名的例子是，訊號處理函式signal，它的定義如下：

typedef void (*HANDLER)(int);
HANDLER signal(int ,HANDLER);
複製程式碼

上面的程式碼定義了信函處理函式signal，它的返回值型別為HANDLER，有兩個引數分別為int、HANDLER。 這樣避免了要這樣定義signal函式：

void (*signal (int ,void(*)(int) ))(int)
複製程式碼

本文參考C++專案中的extern "C" {},該文十分清晰易懂，為了讓更多人看到而轉載。

相關文章