无需C++源码与头文件，能否用Python封装C++ DLL？

Absolutely, you can call that C++ DLL from Python without needing to recompile the original source code or rely on header files—though it does require a bit of manual legwork since C++ classes aren't natively compatible with C-level interop tools like ctypes. Let’s break down the most practical options for you:

cppyy is a Clang-based tool that can directly load C++ DLLs and interact with their classes/functions without pre-compiling binding code. It even works without header files (though having them makes things more accurate and less error-prone).

Step-by-Step Example: #

First, install it via pip:

pip install cppyy

Then load your DLL and interact with the class:

import cppyy

# Load your DLL (replace with your actual DLL path)
cppyy.load_library("your_target_dll.dll")

# If you don't have the header file, manually declare the class structure (must match the DLL's actual class exactly!)
cppyy.cppdef("""
class MyClass {
public:
    MyClass(int initial_value);  // Match the constructor signature from the DLL
    int get_current_value();     // Match all member method signatures
    void update_value(int new_val);
};
""")

# Now you can use the class just like you would in C++
my_obj = cppyy.gbl.MyClass(42)
print(my_obj.get_current_value())  # Should output 42
my_obj.update_value(100)
print(my_obj.get_current_value())  # Should output 100

If you do have access to the original header file, skip the manual declaration and just use cppyy.include("path/to/your_class.h")—this ensures perfect type matching and avoids silly mistakes from manual typing.

C++ classes are just memory blocks under the hood, and their member functions use name-mangled symbols (thanks to C++'s function overloading). You can manually map these mangled names with ctypes, but it’s more tedious and fragile.

Step-by-Step Example: #

First, find the mangled export names of your class functions. On Windows, use dumpbin /exports your_dll.dll; on Linux/macOS, use nm -D your_dll.so. You’ll see names like ?0MyClass@@QEAA@H@Z for a constructor that takes an integer.

Then use ctypes to call them:

import ctypes

# Load the DLL
dll = ctypes.CDLL("your_target_dll.dll")

# Map the mangled constructor (adjust the name to match your DLL's export)
MyClass_ctor = dll["?0MyClass@@QEAA@H@Z"]
MyClass_ctor.argtypes = [ctypes.c_int]
MyClass_ctor.restype = ctypes.c_void_p  # Returns a pointer to the class instance

# Map the mangled destructor
MyClass_dtor = dll["?1MyClass@@QEAA@XZ"]
MyClass_dtor.argtypes = [ctypes.c_void_p]
MyClass_dtor.restype = None

# Map a member function (e.g., get_current_value)
MyClass_get_value = dll["?get_current_value@MyClass@@QEAAHXZ"]
MyClass_get_value.argtypes = [ctypes.c_void_p]
MyClass_get_value.restype = ctypes.c_int

# Use the class (always clean up with the destructor to avoid memory leaks!)
obj_ptr = MyClass_ctor(42)
try:
    print(MyClass_get_value(obj_ptr))  # Output: 42
finally:
    MyClass_dtor(obj_ptr)  # Don't forget to free memory!

This method is fragile—if the DLL was compiled with a different compiler, the name mangling might differ, and handling virtual functions gets even more complex. But it works if you can’t use third-party tools.

If you can get your hands on the class header file (even if you don’t recompile the original DLL), you can write a tiny C wrapper that exposes C-style functions for the C++ class. Then compile this wrapper into a small auxiliary DLL, which ctypes can call easily.

Example Wrapper Code (wrapper.cpp): #

#include "your_class_header.h"  // Use the original class header from the DLL's source
extern "C" {  // Ensures no C++ name mangling
    void* MyClass_Create(int initial_val) {
        return new MyClass(initial_val);
    }

    int MyClass_GetValue(void* obj) {
        return static_cast<MyClass*>(obj)->get_current_value();
    }

    void MyClass_SetValue(void* obj, int new_val) {
        static_cast<MyClass*>(obj)->update_value(new_val);
    }

    void MyClass_Destroy(void* obj) {
        delete static_cast<MyClass*>(obj);
    }
}

Compile this into a DLL (e.g., with g++ -shared -o wrapper.dll wrapper.cpp on Windows, or equivalent commands on other OSes). Then use ctypes to call these simple C functions—no mangling, no complex memory tricks.

For your use case, cppyy is hands down the best bet—it avoids the hassle of manual mangling and doesn’t require any compilation. If you can’t use third-party libraries, the manual ctypes approach works but requires careful attention to the DLL’s export symbols.

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