函数:

Case1:

void foo()

{

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

def("foo",foo);

case2: 引用做返回值

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

 

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
     
      ());        class_
      
       ("World",init<>())                .def(init
       
        ()) //            //静态函数定义 . 下面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
        
         ())        .def_readonly("name", &World::name)        .def_readwrite("value", &World::value)        ;    class_
         
          ("xbs",init
          
           ());}
          
         
        
       
      
     

附加:

如果一个类是抽象类  那么类必须声明: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)