如何通过Boost Python在运行时创建并绑定自定义数据类型？

Great question! You're right that the standard BOOST_PYTHON_MODULE macro ties you to compile-time type definitions—it's designed to set up bindings when a module is imported, not modify types on the fly. But Boost Python exposes lower-level, runtime-friendly APIs that let you dynamically create and register custom types, perfect for your use case of loading type info from a file like Rectangle.xls.

Here are two practical approaches:

1. Dynamically Instantiate boost::python::class_ Objects #

Instead of relying on the compile-time macro, you can directly create class_ instances at runtime and register them with a Python module or namespace. This works if you have a corresponding C++ type (or a generic type that can adapt to your dynamic schema).

Example Code: #

#include <boost/python.hpp>
namespace py = boost::python;

// Assume we have a C++ Rectangle type (could be a generic struct/adapter)
struct Rectangle {
    int width, height;
    Rectangle(int w, int h) : width(w), height(h) {}
    int get_area() const { return width * height; }
};

void create_dynamic_rectangle_type() {
    // Get access to the Python main namespace (or a custom module)
    py::object main_module = py::import("__main__");
    py::object main_namespace = main_module.attr("__dict__");

    // Dynamically create the Python class binding
    py::class_<Rectangle>* rect_class = new py::class_<Rectangle>(
        "Rectangle",  // Python class name
        py::init<int, int>()  // Constructor
    );
    
    // Add methods to the class
    rect_class->def("get_area", &Rectangle::get_area);
    
    // Register the class in the Python namespace
    main_namespace["Rectangle"] = *rect_class;
}

Key Notes: #

• Manage the lifetime of your class_ object carefully—ensure it exists as long as Python might use the type.
• If your dynamic types don't map to pre-defined C++ classes, consider using a generic struct with dynamic attributes (or wrap Python's own object model, see approach 2).

2. Combine Boost Python with Python's Native type() Function #

Python natively supports runtime class creation via the type() built-in. You can use Boost Python to call this function, then bind C++ logic as methods/attributes for the dynamically created class. This is ideal if your type schema is completely dynamic (no pre-existing C++ type).

Example Code: #

#include <boost/python.hpp>
namespace py = boost::python;

// C++ functions to handle the dynamic type's logic
void rectangle_init(py::object self, int width, int height) {
    // Store attributes directly on the Python object
    self.attr("width") = width;
    self.attr("height") = height;
}

int rectangle_get_area(py::object self) {
    int w = py::extract<int>(self.attr("width"));
    int h = py::extract<int>(self.attr("height"));
    return w * h;
}

void create_dynamic_rectangle_from_schema() {
    // Get Python's built-in object class (base for our dynamic type)
    py::object builtins = py::import("builtins");
    py::object base_class = builtins.attr("object");

    // Wrap C++ functions into Python callables
    py::object init_func = py::make_function(
        rectangle_init,
        py::default_call_policies(),
        (py::arg("self"), py::arg("width"), py::arg("height"))
    );
    py::object area_func = py::make_function(
        rectangle_get_area,
        py::default_call_policies(),
        py::arg("self")
    );

    // Build the class attribute dictionary
    py::dict class_attrs;
    class_attrs["__init__"] = init_func;
    class_attrs["get_area"] = area_func;

    // Dynamically create the class using Python's type()
    py::object Rectangle = py::type(
        py::str("Rectangle"),  // Class name
        py::make_tuple(base_class),  // Base classes
        class_attrs  // Class attributes/methods
    );

    // Register the class in the main namespace
    py::object main_module = py::import("__main__");
    main_module.attr("__dict__")["Rectangle"] = Rectangle;
}

Key Notes: #

• This approach lets you fully define types from runtime data (like your Rectangle.xls schema)—you can parse the file, extract field names/methods, and build the class_attrs dictionary dynamically.
• Use py::extract and attr() to interact with the Python object's dynamic attributes from C++.

Bonus: Dynamic Module Creation #

If you want to package your dynamic types into a proper Python module (instead of the main namespace), use Boost Python's module::create() API:

py::module dynamic_module = py::module::create("DynamicShapes");
dynamic_module.attr("Rectangle") = Rectangle;
// Python can now import DynamicShapes and use DynamicShapes.Rectangle

Why Your Original Approach Doesn't Work #

The BOOST_PYTHON_MODULE macro expands to a static initialization function that runs when Python imports the module. All type bindings are hardcoded at compile time, so there's no way to modify them after the module is loaded. The methods above bypass this by using Boost Python's runtime APIs to directly interact with Python's type system.

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