C DLL调用C++ DLL可行吗？需注意哪些额外问题？

Absolutely—you can absolutely call functions from a C++ DLL from a C DLL. Since you already know the basics of LoadLibraryA and GetProcAddress, the main hurdles are C++-specific features that don’t play nice with plain C. Let’s walk through the critical things you need to keep in mind:

Key Considerations #

1. Fix Name Mangling with extern "C" #

C++ compilers mangle function names to support features like overloading and namespaces. For example, a simple function int Add(int a, int b) might get turned into something like ?Add@@YAHHH@Z (depending on your compiler). This means GetProcAddress will never find the function using the original name.

The fix is to wrap your C++ DLL’s exported functions in extern "C" to force the compiler to use C-style name decoration (or lack thereof):

// In your C++ DLL source
extern "C" __declspec(dllexport) int Add(int a, int b) {
    return a + b;
}

Now, your C DLL can call GetProcAddress(hCppDll, "Add") and find the function correctly.

2. Stick to C-Compatible Types and Interfaces #

C doesn’t understand C++ constructs like classes, templates, or overloaded functions. If your C++ DLL uses these, you need to wrap them in a C-compatible "wrapper" interface:

For example, if you have a C++ class you need to use from C:

// C++ DLL code
class Calculator {
public:
    int Multiply(int x, int y) { return x * y; }
};

// Wrap the class in C-style functions
extern "C" __declspec(dllexport) void* CreateCalculator() {
    return new Calculator(); // Return opaque pointer
}

extern "C" __declspec(dllexport) int Calculator_Multiply(void* calcPtr, int x, int y) {
    // Cast the opaque pointer back to the C++ class
    return static_cast<Calculator*>(calcPtr)->Multiply(x, y);
}

extern "C" __declspec(dllexport) void DestroyCalculator(void* calcPtr) {
    delete static_cast<Calculator*>(calcPtr);
}

Then in your C DLL, you can use these wrappers:

// C DLL code
#include <windows.h>

// Define function pointer types
typedef void* (*CreateCalculatorFunc)();
typedef int (*CalculatorMultiplyFunc)(void*, int, int);
typedef void (*DestroyCalculatorFunc)(void*);

void UseCppCalculator() {
    HANDLE hCppDll = LoadLibraryA("MyCppCalculator.dll");
    if (!hCppDll) return;

    // Get function pointers
    CreateCalculatorFunc createCalc = (CreateCalculatorFunc)GetProcAddress(hCppDll, "CreateCalculator");
    CalculatorMultiplyFunc multiply = (CalculatorMultiplyFunc)GetProcAddress(hCppDll, "Calculator_Multiply");
    DestroyCalculatorFunc destroyCalc = (DestroyCalculatorFunc)GetProcAddress(hCppDll, "DestroyCalculator");

    if (createCalc && multiply && destroyCalc) {
        void* calc = createCalc();
        int result = multiply(calc, 5, 6);
        destroyCalc(calc);
    }

    FreeLibrary(hCppDll);
}

Note that we use void* as an opaque handle—C code doesn’t need to know what the pointer actually points to, just how to pass it to the wrapper functions.

3. Ensure Consistent Calling Conventions #

C and C++ default to different calling conventions in some compilers (e.g., MSVC uses cdecl for C, but might use stdcall for some C++ functions if they’re marked with WINAPI). Mismatched calling conventions will lead to stack corruption or crashes.

If your C++ function uses stdcall, explicitly declare it in both the DLL and the C function pointer:

// C++ DLL
extern "C" __declspec(dllexport) int __stdcall Subtract(int a, int b) {
    return a - b;
}

// C DLL
typedef int (__stdcall* SubtractFunc)(int, int);

Always double-check that the calling convention matches between the exported function and your C function pointer.

4. Don’t Let C++ Exceptions Leak into C Code #

C has no support for C++ exceptions. If a C++ DLL function throws an exception that escapes to the C caller, it will cause undefined behavior (usually a crash).

Always catch exceptions inside your C++ exported functions and convert them to error codes instead:

extern "C" __declspec(dllexport) int Divide(int a, int b, int* outResult) {
    if (b == 0) {
        return -1; // Error code: division by zero
    }
    try {
        *outResult = a / b;
        return 0; // Success code
    } catch (...) {
        return -2; // Generic error code
    }
}

Your C code can then check the return code to handle errors instead of dealing with exceptions.

5. Match Runtime Libraries and Compilers #

If your C and C++ DLLs are built with different compilers (e.g., MSVC vs. GCC) or different runtime library configurations (e.g., Debug vs. Release, static vs. dynamic linking), you can run into issues with memory management. For example, memory allocated with new in the C++ DLL can’t be safely freed in the C DLL if they use different heaps.

To avoid this:

• Build both DLLs with the same compiler and runtime library settings.
• Or, encapsulate all memory management in the C++ DLL—provide functions to create/destroy any buffers or objects instead of letting C code handle memory directly.

Final Takeaway #

Calling a C++ DLL from a C DLL is totally doable—you just need to bridge the gap between C’s simplicity and C++’s features by using extern "C", wrapping C++ constructs in C-style interfaces, checking calling conventions, handling exceptions properly, and aligning runtime settings.

内容的提问来源于stack exchange，提问作者Ruben