有选择地将函数定义添加到python命名空间

Question

我想控制允许从python代码到达哪个函数。

在这里结构，我为Python定义了一些扩展的函数：

struct Worldb
{
    void messagewindow(std::string msg) { functions.Messagewindow(msg); }
    void setnumber(int value) { publicnumber=value; }
    string getnumber() { return functions.converttostring(publicnumber); }
    int publicnumber;
};

以下是代码，我将代码添加到代码中并将Python代码发送到编译器：

Py_Initialize();

worldb.publicnumber = 1;

bp::object main_module = bp::import("__main__");
bp::object main_namespace = main_module.attr("__dict__");


main_namespace["Worldb"] = bp::class_<Worldb>("Worldb")
    .def("messagewindow", &Worldb::messagewindow)
    .def("setnumber", &Worldb::setnumber)
    .def("getnumber", &Worldb::getnumber);

main_namespace["cpp"] = bp::ptr(&worldb);//to prevent the worldb object copied 

bp::object compileit;
try
{
     compileit = exec(
         "cpp.messagewindow(cpp.getnumber())\n"
        "cpp.setnumber(8)\n",
        main_namespace);

}
catch(bp::error_already_set &)

我可以使用.def轻松地将函数扩展到Python中，但我找不到任何解决方案将它放在某种“if”语句中，以检查它是否允许添加到python中。当然，我可以将每个函数放入一个独特的命名空间，但这远非优雅，我认为它也可能浪费一些内存。

对不起，我的英文不好，谢谢你给我的任何建议。

Answer 1

没有必要在一个语句中包含所有内容 - 链接调用的能力只是一个方便的问题（def和其他成员函数返回对它们被调用的实例的引用以实现这一点）。

如果我们分析声明

main_namespace["Worldb"] = bp::class_<Worldb>("Worldb")
    .def("messagewindow", &Worldb::messagewindow)
    .def("setnumber", &Worldb::setnumber)
    .def("getnumber", &Worldb::getnumber);

我们将看到它按顺序执行以下功能：

• 创建class_<Worldb>的新实例
• 调用其成员函数def来暴露messagewindow
• 调用其成员函数def来暴露setnumber
• 调用其成员函数def来暴露getnumber
• 将它分配给main_namespace["Worldb"]。

我们可以通过以下方式将每个部分重写为单独的语句来重写它：

{
    bp::class_<Worldb> test_binding = bp::class_<Worldb>("Worldb");
    test_binding.def("messagewindow", &Worldb::messagewindow);
    test_binding.def("setnumber", &Worldb::setnumber);
    test_binding.def("getnumber", &Worldb::getnumber);

    main_namespace["Worldb"] = test_binding;
}

注意：我们引入了一个新的范围来限制test_binding的生命周期，这在分配后不再需要。

这样做之后，有条件地揭示各个方法是微不足道的。

示例代码

#include <boost/python.hpp>

namespace bp = boost::python;

struct test
{
    void one() {}
    void two() {}
    void three() {}
};

int main()
{
    Py_Initialize();

    try {
        bp::object main_module = bp::import("__main__");
        bp::object main_namespace = main_module.attr("__dict__");

        // Simple bitmap of methods to expose:
        // * bit 0 -> one()
        // * bit 1 -> two()
        // * bit 2 -> three()
        uint32_t method_mask(5);

        {
            // Limit the scope of `test_binding` variable
            bp::class_<test> test_binding = bp::class_<test>("test");
            if ((method_mask & 1) == 1) {
                test_binding.def("one", &test::one);
            }
            if ((method_mask & 2) == 2) {
                test_binding.def("two", &test::two);
            }
            if ((method_mask & 4) == 4) {
                test_binding.def("three", &test::three);
            }

            main_namespace["test"] = test_binding;
        }

        exec("print dir(test)\n", main_namespace);
    } catch (bp::error_already_set &) {
        PyErr_Print();
    }

    Py_Finalize();

    return 0;
}

控制台输出

注意：我们预计会暴露one()和three()。我重新格式化了输出以获得更好的可读性。

['__class__', '__delattr__', '__dict__', '__doc__', '__format__'
    , '__getattribute__', '__hash__', '__init__', '__instance_size__'
    , '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__'
    , '__sizeof__', '__str__', '__subclasshook__', '__weakref__'
    , 'one', 'three']

参考

• boost::python::class_的文档