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)