相关疑难解决方法(0)

我正在尝试编写一些包装类或函数,它允许我在包装函数之前和之后执行一些代码.

float foo(int x, float y)
{
    return x * y;
}

BOOST_PYTHON_MODULE(test)
{
     boost::python::def("foo", <somehow wrap "&foo">);
}

理想情况下,包装器应该是通用的,适用于函数和成员函数,具有任何签名.

更多信息:

我正在寻找一种简单的方法来释放/重新获取围绕我昂贵的C++调用的GIL,而无需手动编写像这样的瘦包装器:

float foo_wrapper(int x, float y)
{
    Py_BEGIN_ALLOW_THREADS
    int result = foo(x, y);
    Py_END_ALLOW_THREADS
    return result;
}

BOOST_PYTHON_MODULE(test)
{
     boost::python::def("foo", &foo_wrapper);
}

对于所有类型的函数,这种包装器将重复多次,我想找到一个允许我避免编码所有函数的解决方案.

我尝试了一些方法,但我能提供的最好的方法是要求用户明确说明返回值和参数的类型,例如:

boost::python::def("foo", &wrap_gil<float, int, float>(&foo_wrapper));

但在我看来应该可以只是将指针传递给函数(&foo_wrapper)并让编译器找出类型.

有谁知道我可以使用的技术或指向正确的方向？

干杯!

我想用C++ 11 lambda表达式作为访问功能boost::python的add_property,沿着下面的内容(拉姆达并不是必需在这个例子中,但将需要更复杂的东西拉姆达内部发生,如验证):

#include<boost/python.hpp>

struct A{
  A(): a(2){};
  int a;
};

BOOST_PYTHON_MODULE(boost_python_lambda)
{
  boost::python::class_<A>("A")
    // .def_readonly("a",&A::a) // the classical way: works fine 
    .add_property("a",[](const A& a){return a.a;})
  ;
}

但是,使用clang ++(版本3.2)编译和-std=c++11(结果与g ++ 4.7相同),我收到此错误:

/usr/include/boost/python/class.hpp:442:66: error: no matching function for call to 'get_signature'
        return python::make_function(f, default_call_policies(), detail::get_signature(f, (T*)0));
                                                                 ^~~~~~~~~~~~~~~~~~~~~
/usr/include/boost/python/class.hpp:422:22: note: in instantiation of function template specialization 'boost::python::class_<A,
      boost::python::detail::not_specified, boost::python::detail::not_specified,
      boost::python::detail::not_specified>::make_fn_impl<A, <lambda at boost_python_lambda.cpp:12:21> >' requested here
        return this->make_fn_impl(
                     ^
/usr/include/boost/python/class.hpp:309:40: note: in instantiation of function …

我有一个很小的 ​​Python 脚本，它（在我看来）threading.Thread.start()由于它不会立即返回而导致行为出乎意料。

在一个线程中，我想从一个boost::python不会立即返回的基于对象调用一个方法。

为此，我像这样包装对象/方法：

import threading
import time
import my_boostpython_lib

my_cpp_object = my_boostpython_lib.my_cpp_class()

def some_fn():
    # has to be here - otherwise .start() does not return
    # time.sleep(1)  
    my_cpp_object.non_terminating_fn() # blocks

print("%x: 1" % threading.get_ident())
threading.Thread(target=some_fn).start()
print("%x: 2" % threading.get_ident())  # will not always be called!!

只要我在 my_cpp_object.non_terminating_fn(). 如果我不这样做，.start()将像.run()直接调用一样阻塞。

在调用boost::python函数之前只打印一行是不够的，但是例如打印两行或调用time.sleep()使start()按预期立即返回。

你能解释一下这种行为吗？我将如何避免这种情况（除了sleep()在调用boost::python函数之前调用）？

I'm writing a python program that includes a c++ module (.so, using boost.python).
I'm starting several python threads that run a c++ function.

This is how the C++ code looks like:

#include <boost/python.hpp>
using namespace boost;
void f(){
    // long calculation

    // call python function

    // long calculation
}

BOOST_PYTHON_MODULE(test)
{
    python::def("f", &f);
}

And the python code:

from test import f
t1 = threading.Thread(target=f)
t1.setDaemon(True)
t1.start()
print "Still running!"

I encounter a problem: the "Still running!" …