BOOST.PYTHON 封装C++全面整合

函数:

Case1:

void foo()
{

}  //没有重载 没用默认参数 没有用引用做返回

def("foo",foo);

case2: 引用做返回值

std::string& foo4(std::string& a)
{    
    return a;
}
def("foo4",foo4,return_value_policy<reference_existing_object>());

 

case3: 有重载

void foo(int i)
{

}
void foo(Ogre::Real a, Ogre::Real b)
{
    /*...*/
}
BOOST_PYTHON_MODULE(hello) 
{         
    def("foo",(void (*)(Ogre::Real, Ogre::Real))&foo);
    def("foo",(void(*)(Ogre::Real))&foo);  

}

在定义的时候必须制定函数的版本.

case4 参数有默认值

void foo2(int h,int i=200)
{
}
BOOST_PYTHON_FUNCTION_OVERLOADS(foo_overloads, foo2, 1,2)
BOOST_PYTHON_MODULE(hello) 
{         
    def("foo2",foo2,foo_overloads());    
}

默认参数其实就是函数重载了.即参数个数可以不一样, 可以有1个 也可以有2个

BOOST_PYTHON_FUNCTION_OVERLOADS(foo_overloads, foo2, 1,2)      1 2 表示参数的最小数量和最大数量

一个综合一点的:

 

void foo2(float c)
{

}
void foo2(int h,int i=200)
{
}
void foo(Ogre::Real i)
{

}
void foo(Ogre::Real a, Ogre::Real b)
{
    /*...*/
}
BOOST_PYTHON_FUNCTION_OVERLOADS(foo_overloads,foo2, 1,2);
BOOST_PYTHON_MODULE(hello) 
{         
    def("foo2",(void(*)(float))&foo2);
    def("foo2",(void(*)(int,int))&foo2,foo_overloads());
    def("foo",(void (*)(Ogre::Real,Ogre::Real))&foo);
    def("foo",(void(*)(Ogre::Real))&foo);
}

另注意: 传入 python的引用 必须要在python中申明, 比如传入std::string 引用  那么必须导入std::string类.

 

类 来一个综合一点的:

struct World
{
    World(){};
    World(std::string msg): msg(msg) {} // added constructor
    static void ccc()
    {

    }
    void foo()
    {
    }
    void foo(int i)
    {

    }
    void set(std::string msg) { this->msg = msg; }
    std::string& greet() { return mm; }
    std::string msg;
    std::string const name;
    float value;
};
World* testw;
World* getWorld()
{
    return testw;
}
BOOST_PYTHON_MODULE(hello) 
{         
    //返回指针
    def("getWorld",(World*(*)())getWorld,return_value_policy<manage_new_object>());    
    class_<World>("World",init<>())        
        .def(init<std::string>()) //    
        //静态函数定义 . 下面2行是必须的
        .def("ccc",&World::ccc)
        .staticmethod("ccc")
        .def("foo",(void(World::*)())&World::foo)
        .def("foo",(void(World::*)(int))&World::foo)
        //返回引用
        .def("greet",&World::greet,return_value_policy<reference_existing_object>())
        .def_readonly("name", &World::name)
        .def_readwrite("value", &World::value)
        ;
    class_<std::string>("xbs",init<const char*>());
}

附加:

如果一个类是抽象类  那么类必须声明:class_<World,boost::nocopyable>("World",no_init) ;

如果返回值类型为 void* 那么返回值方针必须是:return_value_policy<return_opaque_pointer>())   

如果返回值为T *(T为一个class) , 并且这个T的析构函数不是public 那么返回值方针也必须是return_value_policy<return_opaque_pointer>())   

实际上: 如果一个T * 返回通过return_value_policy<manage_new_object>()) 方针.

比如 A* ttt();   那么在python中使用 tmpA=TEST.ttt().    tmpA实际上不是指针类型. 已经被转换成引用了. 通过type(tmpA) 可知: tmpA的类型是 TEST.A

如果返回值为方针是:return_value_policy<return_opaque_pointer>())      那么返回的就是指针. 此时type(tmpA) 的类型是: class A*

此时你调用tmpA的任何东西都会出错. 因为没有指针这个类型在python中. 

那么怎么用呢????  如果在python中返回了一个指针. 你只能继续注册一个函数 返回他的引用:

A& getA(A* _a)

{
   return *_a;
}

在python中  realA=getA(tmpA) 这个时候就可以调用A中的东西了. 

哎 BOOST PYTHON 真操蛋啊. 每一份说明文档 全部靠自己手动去实验了  , 竖中指(fuck)