Question

我向Python公开了一些嵌套enum的C ++类。查看boost.org和wiki.python.org处的示例文档，我无法看到在输入范围后如何离开范围，以便返回到全局/模块范围。相反，每个后续范围都嵌套在前一个范围内。

举个例子：

#include <boost/python.hpp>

class Foo
{
public:
    enum Choose { eFoo, eBar };

    /* Default constructor with enum as required argument */
    Foo(Choose choice): m_choice(choice) {}
    ~Foo() {}

    Choose get() const { return m_choice; }

private:
    const Choose m_choice;

};


class Bar
{
};

BOOST_PYTHON_MODULE(foo)
{
    using namespace boost::python;
    scope global;

    /* Define Foo class, and a scope to go with it. */
    scope in_Foo = class_<Foo>
        ("Foo", init<Foo::Choose>())
        .def("rovalue", &Foo::get)
        ;

    /* Expose 'Choose' enum as Foo.Choose */
    enum_<Foo::Choose>("Choose")
        .value("Foo", Foo::eFoo)
        .value("Bar", Foo::eBar)
        ;

    /* How to get back to module scope??  */
    global;
    scope();

    /* This currently is exposed as Foo.Bar, but should just be Bar */
    class_<Bar>("Bar", init<>())
        ;
}

我已尝试将global;行更改为各种内容，但所有结果都相同：

$ g++ -fPIC -shared scope.cpp -o foo.so -lpython2.7 -I/usr/include/python2.7 -lboost_python
$ python -c 'import foo; print "Bar" in dir(foo)'
False
$ python -c 'import foo; print "Bar" in dir(foo.Foo)'
True

修改

再看一下wiki.python.org，似乎在上面的例子中，正确的答案是使用scope within(global)恢复到模块级范围。实际上，这适用于上面的例子。不幸的是，当我在实际应用程序中使用它时出现编译错误。

#include <boost/python.hpp>
using namespace boost;
BOOST_PYTHON_MODULE(foo)
{
    python::scope module_level;
    /* .... */
    python::scope python::within(module_level);
    /* ... */
}

编译错误：

error: invalid use of qualified-name 'boost::python::within'

Answer 1

具有讽刺意味的是，并且可能因其自身利益而过于聪明，这可以使用C ++范围来实现。 boost::python::scope文档指出当scope对象的生命周期结束时，当前范围将恢复为构造scope对象之前的范围。

BOOST_PYTHON_MODULE(foo)              // set scope to foo
{
  using namespace boost::python;
  {
    scope in_Foo = class_<Foo>        // define foo.Foo and set scope to foo.Foo
        ("Foo", init<Foo::Choose>())
        .def("rovalue", &Foo::get)
        ;

    enum_<Foo::Choose>("Choose")     // define foo.Foo.Choose
        .value("Foo", Foo::eFoo)
        .value("Bar", Foo::eBar)
        ;
  }                                  // revert scope, setting scope to foo

  class_<Bar>("Bar", init<>())       // define foo.Bar
      ;
}

虽然scope个对象可以通过其他方式管理其生命周期，但我发现使用scope个对象作为C ++范围内的自动变量可以为C ++命名空间提供一些并行性。

Boost.Python - 如何重新输入模块范围？

1 个答案: