C呼叫C++ DLL：深入剖析跨語言函數調用的奧秘與實戰

Byadmin

C呼叫C++ DLL：深入剖析跨語言函數調用的奧秘與實戰

您好！是不是最近在進行專案開發時，遇到了這樣一個令人頭疼的狀況：您手握著一手用 C 語言寫好的程式碼，但卻需要調用一個功能強大、已經編譯成 C++ DLL 的函式庫？別擔心，這絕對是許多開發者都會碰到的「瓶頸」之一，我也是過來人，當年為了這個問題可是絞盡腦汁！不過，請您放心，這篇文章就是為了解決您的困擾而生的。

簡單來說，C 呼叫 C++ DLL 是一個常見的跨語言編譯和調用問題，透過適當的介面定義和編譯器設定，C 程式是可以成功呼叫 C++ DLL 中定義的函式的。這聽起來有點抽象，但實際上，只要我們掌握了幾個關鍵的技術點，這個過程就會變得清晰明瞭。這篇文章將帶您深入了解其原理、步驟，並提供實用的範例，讓您輕鬆駕馭這個技術挑戰。

為何需要 C 呼叫 C++ DLL？

在軟體開發的領域裡，模組化和重複利用是永恆的主題。很多時候，我們會發現一些高度優化、功能複雜的程式碼是以 C++ 編寫的，並且被封裝成 DLL（動態連結函式庫）。這些 DLL 可能包含了高效的演算法、成熟的第三方函式庫，或是已經驗證過的業務邏輯。而另一方面，我們可能需要用 C 語言來開發一個系統，例如嵌入式系統、作業系統底層介面，或是需要高度可移植性的應用程式。這時候，如何讓 C 程式能夠「聽懂」並「使用」 C++ DLL 中的功能，就成了一個迫切的需求。

這種跨語言呼叫的優勢不言而喻：

  • 程式碼重用： 避免重複造輪子，直接利用現有的 C++ 函式庫。
  • 效能優化： C++ 在某些面向，例如物件導向、模板等，可以提供更強大的表達能力和更高效的效能。
  • 專案整合： 將不同語言開發的模組無縫整合到同一個專案中。
  • 封裝複雜性： 將 C++ 的複雜實現細節隱藏在 DLL 中，提供簡單的 C 介面給 C 程式調用。

C++ DLL 的 C 介面：關鍵的橋樑

C++ 的強大之處在於其物件導向的特性，例如類別（class）、繼承、多型等等。然而，這些特性在 C 語言中是無法直接理解的。因此，當我們希望 C 程式能夠呼叫 C++ DLL 時，最核心的問題就是如何為 C++ 的函式或類別建立一個 C 語言能夠理解的「介面」。這個介面就是所謂的「C 介面」。

C 語言的函式呼叫機制非常簡單，它依賴於函式名稱、參數的資料類型以及呼叫約定（calling convention）。而 C++ 則有更複雜的名稱修飾（name mangling）機制，這會讓函式名稱變得難以預測，不利於 C 程式直接找到。同時，C++ 的類別和物件也無法被 C 直接處理。

為了克服這些障礙，我們需要採用一些特殊的語法和技巧來建立 C 語言可用的介面。最常用的方式就是使用 `extern “C”`。

`extern “C”` 的作用

`extern “C”` 是一個 C++ 的連結指示符（linkage specification）。當您將一段 C++ 程式碼用 `extern “C”` 包裹起來時，您是在告訴 C++ 編譯器：「請將這段程式碼中的函式按照 C 語言的連結規則來處理。」這意味著：

  • 禁用名稱修飾： C++ 編譯器不會對這些函式進行名稱修飾，使其名稱保持原始的樣子，C 程式才能透過名稱正確找到它們。
  • 使用 C 呼叫約定： 函式的參數傳遞和返回值處理將遵循 C 語言的規則，通常是將參數壓入堆疊（stack），並由呼叫者負責清理堆疊。
  • 不支援 C++ 特性： 在 `extern “C”` 區塊內，您不能直接使用 C++ 的類別、物件、參考（reference）等特性。

實際操作步驟：從 C++ DLL 到 C 程式的調用

要實現 C 呼叫 C++ DLL，通常需要以下幾個關鍵步驟。我將以一個簡單的範例來詳細說明：我們將建立一個 C++ DLL，其中包含一個加法函式，然後在 C 程式中呼叫它。

步驟一：建立 C++ DLL 專案

首先，我們需要一個 C++ 編譯器，例如 Visual Studio。

  1. 啟動 Visual Studio。
  2. 建立一個新的專案。選擇「動態連結函式庫 (DLL)」範本。
  3. 專案名稱可以設定為 `MyCppLibrary`。
  4. 請確保您選擇的是 C++ 專案。

步驟二：定義 C++ DLL 的函式並提供 C 介面

在 C++ DLL 的專案中，我們需要定義一個函式，並且確保它能夠被 C 程式調用。這就是我們需要 `extern “C”` 的地方。

假設我們的 DLL 需要提供一個加法函式。

MyCppLibrary.h (C++ Header File)
#pragma once

// 為了讓 C 程式能正確連結，我們需要定義一個 C 連結的介面
// 如果是從 C 程式引入這個標頭檔，__cplusplus 會被定義
// 如果是從 C++ 編譯器編譯這個標頭檔，__cplusplus 也是被定義的
// 所以我們可以用這個來判斷，確保 extern "C" 只在 C++ 編譯時生效
#ifdef __cplusplus
extern "C" {
#endif

    // 宣告一個我們希望 C 程式調用的加法函式
    // 我們將這個函式暴露為 C 語言可理解的格式
    int AddNumbers(int a, int b);

    // 假設我們還有一個函式，需要傳遞字串
    // 注意：在 C 語言中，字串通常以 char* 表示
    void DisplayMessage(const char* message);

#ifdef __cplusplus
}
#endif

在這裡，`AddNumbers` 和 `DisplayMessage` 這兩個函式都被包在 `extern “C” { … }` 裡面。這意味著，當 C++ 編譯器編譯這個檔案時，它會產生 C 語言格式的函式名稱和呼叫約定。

MyCppLibrary.cpp (C++ Source File)
#include "MyCppLibrary.h"
#include <iostream> // 僅用於演示，實際 DLL 輸出不應依賴標準輸出

// 這裡的函式定義，由於在 MyCppLibrary.h 中被 extern "C" 包裹
// 所以它們也會被編譯成 C 連結的格式
int AddNumbers(int a, int b) {
    return a + b;
}

void DisplayMessage(const char* message) {
    // 在實際的 DLL 中，通常不會直接輸出到控制台，
    // 而是透過 log 或其他機制。這裡僅為方便演示。
    std::cout << "Message from C++ DLL: " << message << std::endl;
}

步驟三：編譯 C++ DLL

在 Visual Studio 中，您只需建置 (Build) 您的專案。這將會在專案的輸出目錄（通常是 `Debug` 或 `Release` 資料夾）產生一個 `.dll` 檔案（例如 `MyCppLibrary.dll`）和一個 `.lib` 檔案（匯入函式庫，例如 `MyCppLibrary.lib`）。

步驟四：建立 C 專案

現在，我們需要建立一個 C 程式來呼叫這個 DLL。

  1. 開啟 Visual Studio，建立一個新的專案。
  2. 選擇「主控台應用程式」範本，並確保專案類型是 C。
  3. 專案名稱可以設定為 `CallCppDll`。

步驟五：在 C 專案中引入 C++ DLL 的標頭檔與連結

為了讓 C 程式能夠呼叫 DLL 中的函式，我們需要執行以下操作：

  1. 將 C++ DLL 的標頭檔（`MyCppLibrary.h`）複製到您的 C 專案的目錄下，或者將 C++ 專案的標頭檔目錄添加到 C 專案的包含目錄中。
  2. 將 C++ DLL 專案產生的 `.lib` 檔案（匯入函式庫）複製到 C 專案的目錄下，或者將 C++ 專案的輸出目錄添加到 C 專案的連結器附加函式庫目錄中。
  3. 在 C 專案的連結器設定中，將 `.lib` 檔案名稱添加到「附加相依性」中。

具體操作步驟（以 Visual Studio 為例）：

  • 在 C 專案中，右鍵點擊「方案總管」中的專案名稱，選擇「屬性」。
  • 導航到「C/C++」->「一般」->「其他包含目錄」，添加 C++ DLL 的標頭檔所在目錄。
  • 導航到「連結器」->「一般」->「其他函式庫目錄」，添加 C++ DLL 的 `.lib` 檔案所在目錄。
  • 導航到「連結器」->「輸入」->「其他相依性」，添加 `MyCppLibrary.lib`。

步驟六：編寫 C 程式呼叫 DLL 函式

main.c (C Source File)
#include <stdio.h>
#include "MyCppLibrary.h" // 引入我們定義的 C 介面標頭檔

int main() {
    int num1 = 10;
    int num2 = 20;
    int sum;

    // 呼叫 C++ DLL 中的 AddNumbers 函式
    sum = AddNumbers(num1, num2);
    printf("The sum of %d and %d is: %d\n", num1, num2, sum);

    // 呼叫 C++ DLL 中的 DisplayMessage 函式
    const char* message = "Hello from C program!";
    DisplayMessage(message);

    return 0;
}

步驟七：執行 C 程式

在 C 專案中建置並執行程式。請確保 C++ DLL 的 `.dll` 檔案與 C 可執行檔位於同一目錄下，或者 DLL 所在的目錄已經被系統的 PATH 環境變數包含。當您執行 C 程式時，它會載入 C++ DLL，並成功呼叫其中的函式。

處理 C++ 特性：物件、字串和異常

前面我們處理的是簡單的函式呼叫。但如果 C++ DLL 中包含物件、更複雜的資料結構，或是需要處理異常，那麼事情就會變得更複雜一些。

物件的調用

C 語言本身沒有物件的概念。為了讓 C 程式能夠操作 C++ 物件，我們通常會採取以下策略：

  1. 在 C++ DLL 中，為類別的物件建立 C 樣式的介面函式。
  2. 這些函式通常會返回一個 `void*` 指標，指向 C++ 物件的實例。C 程式將這個 `void*` 視為一個不透明的句柄（handle）。
  3. 提供一系列的 C 函式，這些函式接收 `void*` 句柄作為參數，然後在 C++ 層面將其轉換回原始的物件指標，並呼叫物件的方法。
範例：

假設我們有一個 `Calculator` 類別： 

// MyCppLibrary.h (部分)
#ifdef __cplusplus
extern "C" {
#endif

    // 創建 Calculator 物件的函式
    void* CreateCalculator();

    // 銷毀 Calculator 物件的函式
    void DestroyCalculator(void* calc_ptr);

    // 使用 Calculator 物件進行加法的函式
    int CalculatorAdd(void* calc_ptr, int a, int b);

#ifdef __cplusplus
}
#endif

// MyCppLibrary.cpp (部分)
class Calculator {
public:
    int Add(int a, int b) {
        return a + b;
    }
};

extern "C" {
    void* CreateCalculator() {
        // 在 C++ 中創建物件，並返回其指標，但轉換為 void*
        return new Calculator();
    }

    void DestroyCalculator(void* calc_ptr) {
        // 銷毀物件
        if (calc_ptr) {
            delete static_cast<Calculator*>(calc_ptr);
        }
    }

    int CalculatorAdd(void* calc_ptr, int a, int b) {
        // 將 void* 轉換回 Calculator 指標，並呼叫 Add 方法
        if (calc_ptr) {
            Calculator* calc = static_cast<Calculator*>(calc_ptr);
            return calc->Add(a, b);
        }
        return 0; // 或其他錯誤處理
    }
}

在 C 程式中，您將這樣使用： 

// main.c (部分)
#include "MyCppLibrary.h"

int main() {
    void* calculator = CreateCalculator(); // 獲取 Calculator 的句柄
    if (calculator) {
        int result = CalculatorAdd(calculator, 5, 7);
        printf("Calculator result: %d\n", result);
        DestroyCalculator(calculator); // 釋放 Calculator 物件
    }
    return 0;
}

字串處理

C++ 中的 `std::string` 與 C 的 `char*` 是不同的。當您需要在 C 和 C++ DLL 之間傳遞字串時，需要進行轉換。

  • C++ DLL 傳回 C： C++ DLL 可以將 `std::string` 轉換為 `const char*` 並傳回。
  • C 傳回 C++ DLL： C 程式將 `char*` 傳給 C++ DLL，DLL 內部可以將 `char*` 轉換為 `std::string`。

重要提醒： 如果 C++ DLL 需要傳回一個新的 `std::string`，並且 C 程式需要接收它，那麼 C 程式就需要負責釋放 C++ 分配的記憶體，或者 DLL 提供一個釋放函式。直接將 `std::string` 的內部指標（`c_str()`）傳回給 C 程式，並讓 C 程式修改，這是非常危險的，因為 `std::string` 的記憶體管理規則與 C 的 `char*` 不同。

異常處理

C++ 的異常（exception）機制在 C 語言中是無法直接捕捉的。如果您在 C++ DLL 中使用了 `try-catch` 區塊，那麼當異常發生時，如果沒有被 `extern “C”` 函式內部捕獲，程式就會崩潰。

為了在 C 程式中處理 C++ 異常，通常的做法是：

  • 在 `extern “C”` 函式內部使用 `try-catch` 區塊。
  • 如果在 `catch` 區塊中捕獲到異常，可以返回一個特定的錯誤碼，或者將錯誤資訊儲存到一個全域變數（或透過傳入的指標）中，再由 C 程式檢查這個錯誤碼或資訊。

例如： 

// MyCppLibrary.cpp (部分)
#include <stdexcept>

extern "C" {
    int PerformOperation(int a, int b) {
        try {
            if (b == 0) {
                throw std::runtime_error("Division by zero is not allowed.");
            }
            return a / b;
        } catch (const std::exception& e) {
            // 在 C 程式中，通常會定義一個全域變數或傳入指標來報告錯誤
            // 這裡我們簡單返回一個特定的錯誤值
            // 實際應用中，您可能需要一個函式來獲取錯誤訊息
            fprintf(stderr, "Error in DLL: %s\n", e.what()); // 演示輸出
            return -99999; // 自定義錯誤碼
        }
    }
}

C 程式需要檢查這個返回值。

跨平台考量與編譯器選項

當我們談論 DLL 時，通常會想到 Windows 平台。在 Linux 或 macOS 等 Unix-like 系統上，對應的概念是共享函式庫（Shared Libraries），檔案通常是 `.so`（Linux）或 `.dylib`（macOS）。

雖然基本原理相同，但不同作業系統和編譯器之間的差異需要注意：

  • 呼叫約定： Windows 上的 `__cdecl` (預設的 C 呼叫約定), `__stdcall` (Windows API 常用的), `__fastcall` 等。Linux/macOS 上的呼叫約定通常更標準化。確保 C 和 C++ DLL 使用相同的呼叫約定。在 Visual Studio 中，`extern “C”` 通常會使用 C 的預設呼叫約定。
  • 名稱修飾： 雖然 `extern “C”` 能解決大部分問題，但不同編譯器對 C 連結的名稱修飾可能略有不同，不過標準情況下是相容的。
  • 建置系統： 您可能需要使用 CMake、Makefile 等工具來管理跨平台的建置過程，確保 DLL 和可執行檔能夠在不同系統上正確生成和連結。

如果您使用 GCC 或 Clang 編譯 C++ DLL（生成 `.so` 檔案），並且在 C 程式中連結，做法類似：

  • C++ DLL 標頭檔：同樣使用 `extern “C”`。
  • 編譯 C++ DLL：`g++ -shared -fPIC -o libmycpplibrary.so MyCppLibrary.cpp` ( `-fPIC` 表示 Position-Independent Code，是共享函式庫必須的)。
  • 編譯 C 程式並連結：`gcc main.c -L. -lmycpplibrary -o callcppdll` ( `-L.` 表示在當前目錄尋找函式庫，`-lmycpplibrary` 表示連結 `libmycpplibrary.so` 或 `libmycpplibrary.a` )。

常見問題與疑難排解

Q1：編譯 C 程式時，連結器報錯 “unresolved external symbol” 是什麼意思？

這通常意味著 C 編譯器找不到您在程式碼中呼叫的函式。可能的原因包括：

  • 您沒有將 C++ DLL 的 `.lib` 檔案（匯入函式庫）添加到 C 專案的連結器設定中。
  • `.lib` 檔案的名稱或路徑設定錯誤。
  • C++ DLL 中的函式名稱與 C 程式呼叫的名稱不符（例如，忘記使用 `extern “C”`，導致 C++ 編譯器進行了名稱修飾，C 程式找不到原始名稱）。
  • C++ DLL 並沒有包含您嘗試呼叫的那個函式。

請仔細檢查上述步驟，特別是連結器設定和 `extern “C”` 的使用。

Q2：執行 C 程式時，出現「程式無法啟動，因為此電腦缺少 XXX.dll」的錯誤？

這是一個典型的「執行階段錯誤」，表示您的 C 可執行檔在執行時找不到它所依賴的 DLL。原因通常是：

  • C++ DLL 的 `.dll` 檔案沒有放在 C 可執行檔的相同目錄下。
  • `.dll` 檔案所在的目錄沒有被加入系統的 PATH 環境變數中。
  • C++ DLL 依賴於其他 DLL，而那些 DLL 也沒有被找到。

最簡單的解決方法是將 `.dll` 檔案複製到 C 可執行檔的旁邊。

Q3：C++ DLL 中的 `std::cout` 輸出為什麼看不到？

當 DLL 被獨立載入時，它通常不會自動連結到主控台輸出。如果您希望 DLL 的輸出能顯示在 C 程式的主控台，您需要在 C 程式中呼叫 DLL 中的函式，讓 C 程式來負責輸出，或者 DLL 提供一個回調（callback）機制，讓 C 程式提供一個輸出函式給 DLL 調用。

簡單的做法是在 C 程式中，將 DLL 傳回的字串進行 `printf`。

Q4：我嘗試傳遞 `std::string` 給 C 程式，但出現亂碼或崩潰，該如何處理？

如前所述，`std::string` 和 C 的 `char*` 是不同的。您不能直接將 `std::string` 的內部字串指標傳給 C 程式，並期望 C 程式能夠理解其生命週期和記憶體管理。

正確的做法是：

  • 如果 DLL 需要傳遞一個字串給 C，DLL 應當：

    • 將 `std::string` 轉換為 `const char*` 傳回（如果字串內容是 DLL 內部管理的，C 程式只能讀不能改）。
    • 或者，DLL 動態分配記憶體來儲存字串，然後將 `char*` 傳回給 C，同時提供一個單獨的函式讓 C 呼叫以釋放這塊記憶體。
  • 如果 C 需要傳遞字串給 DLL，C 程式直接傳遞 `char*` 即可，DLL 內部再將其轉換為 `std::string`。

總結

C 呼叫 C++ DLL 雖然一開始聽起來可能有點複雜，但掌握了 `extern “C”` 這個關鍵，並理解了 C++ 和 C 在函式呼叫、資料類型、記憶體管理等方面的差異，您就能夠順利地在專案中實現這種跨語言的整合。這項技術讓您可以更靈活地運用現有的程式碼資源，並提升開發效率。過程中多動手實作，多嘗試，您一定能成功駕馭這個強大的技巧！

c呼叫cDLL