} } }

    C++应用ffpython嵌入和扩大python

    添加时间:2013-5-9 点击量:

    择要:


    在办事器编程中,经常会用到python脚本技巧。Python是最风行的脚本之一,并且python拥有定义杰出的C API接口,同时又有雄厚的文档,与C++连络很是的合适。凡是景象下应用C++封装机制,而用python脚本实现策略或者是把握。应用python和C++连络的技巧拥有如下上风:



    • l  主系十足应用C++实现,对峙体系的高效。

    • l  把握项目组应用python,增长开辟效力,python的内存垃圾收受接管,雄厚的类库都使C++开辟者获益匪浅。

    • l  Python脚本可以运行期重载,可以实现把握项目组不绝机热更新。


    C++与python的编程范式有很大不合,当应用python C API调用python时,python中的一些特有机制会给C++开辟者带来很多困惑。经常应用python C API时须要重视如下几点:



    • l  Python 应用引用计数经管内存,调用python C API时对于返回值返回的是借用的引用还是新的引用,须要按照文档细心确认。不然轻则呈现内存泄漏,重则法度溃散。

    • l  Python中的数据布局与C++的有很大不合。Python常用的有tuple,list,dict。而c++常用的事vector,list,map,并且c++是强类型的。当c++与python进行交互时,C++层操纵python数据布局就像操纵c++ STL一样便利,而在python脚本层,又c++传入的参数或返回值都是原生的python数据

    • l  C++中常用的指针传递对象,当嵌入python时,须要把c++对象传递到python中。


    Ffpython是专门便利C++嵌入python开辟的类库,基于ffpython一方面可以轻松的将python集成到C++体系,另一方面,C++对象或接口也可以很轻易被python应用,总之ffpython简化了c++与python的交互操纵。


    嵌入python


    最简单的应用python的体式格式是把python脚本算作设备,如获取脚本中的一个字符串变量。Python的脚本文件会被python虚拟机import为module,和python的标准库的module实际上是类似的概念。Ffpython封装了获取python module中的变量的操纵。



    printf(sys.version=%s\n, ffpython.get_global_var<string>(sysversion).c_str());



    上方的代码获取python标准库中sys的version变量值,ffpython经由过程模板函数的主动将python的str类型主动适配到c++的string类型。get_global_var是获取变量的接口,与之对应的是设置变量的借口get_global_var:



    ffpython.get_global_var(fftestglobal_varOhNice);
    

    printf(
    fftest.global_var=%s\n, ffpython.get_global_var<string>(fftestglobal_var).c_str());



    调用python函数是嵌入python非经常用的操纵,ffpython中供给了call接口用于调用python中的module的函数:



    printf(time.asctime=%s\n, ffpython.call<string>(timeasctime).c_str());



    上方的代码调用time模块的asctime办法,我们也可以应用call接口调用我们本身编写的函数:



    int a1 = 100; float a2 = 3.14f; string a3 = OhWell;
    

    ffpython.call
    <void>(fftesttest_base, a1, a2, a3);



    Call被定义为模版函数,传入的参数会主动适配到python响应的类型。对应的python函数为:



    def test_base(a1, a2, a3):
    
    printtest_base, a1, a2, a3)
    return 0



    上方的python函数接管三个参数,c++传入了三个标准类型参数,实际上call接口最多支撑9个泛型参数,常用的stl 参数是被支撑的:




    void test_stl(ffpython_t& ffpython)
    
    {
    vector
    <int> a1;a1.push_back(100);a1.push_back(200);
    list
    <string> a2; a2.push_back(Oh);a2.push_back(Nice);
    vector
    <list<string> > a3;a3.push_back(a2);
    ffpython.call
    <bool>(fftesttest_stl, a1, a2, a3);
    }



    对应调用的python函数为:



    def test_stl(a1, a2, a3):
    
    printtest_stl, a1, a2, a3)
    return True



    不单STL泛型被支撑,嵌套定义的类似vector<list<string> > 的布局都是被支撑的,vector和list都邑转换成python的list布局,而map则转换为dict布局。


    调用call接口必须指定接管的返回值类型,可以应用void忽视返回值,除了可以应用标准类型,stl接口也可以被应用,python中的tuple和list可以转换成vector和list,dict则可以被转换成map。须要重视的是,若类型没有匹配,call函数将会抛出异常。用户可以catch标准异常,what接口返回的字符串包含了异常的traceback信息便利排查错误。示例如下:



        try{
    
    ......

    }
    catch(exception& e)
    {
    printf(
    exception traceback %s\n, e.what());
    }



    扩大python


    Ffpython 可以注册static函数到python中,全局的C风格的static函数和类中定义的static函数都可以被注册到python中,示例如下: 



    static int print_val(int a1, float a2, const string& a3, const vector<double>& a4)
    
    {
    printf(
    %s[%d,%f,%s,%d]\n, __FUNCTION__, a1, a2, a3.c_str(), a4.size());
    return 0;
    }
    struct ops_t
    {
    static list<int> return_stl()
    {
    list
    <int> ret;ret.push_back(1024);
    printf(
    %s\n, __FUNCTION__);
    return ret;
    }
    };

    void test_reg_function()
    {
    ffpython_t ffpython;
    ffpython.reg(
    &print_val, print_val
    .reg(
    &ops_t::return_stl, return_stl);
    ffpython.init(
    ext1);
    ffpython.call
    <void>(fftesttest_reg_function);
    }



    以上代码注册了两个接口给python,然后调用fftest文件中的test_reg_function测试两个接口,fftest.py中定义测试代码:



    def test_reg_function():
    
    import ext1
    ext1.print_val(
    123, 45.6 , ----789---, [3.14])
    ret
    = ext1.return_stl()
    printtest_reg_function, ret)



    这两个接口固然简单,然则说了然ffpython注册的接口支撑多个参数,参数类型可所以标准C++类型,也可所以STL泛型。同样返回值的类型也是如此。


    应用ffpython 注册C++的对象也很轻易,ffpython支撑注册c++类的机关函数,成员变量,成员办法到python,示例代码如下:




    class foo_t
    
    {
    public:
    foo_t(
    int v_):m_value(v_)
    {
    printf(
    %s\n, __FUNCTION__);
    }
    virtual ~foo_t()
    {
    printf(
    %s\n, __FUNCTION__);
    }
    int get_value() const { return m_value; }
    void set_value(int v_) { m_value = v_; }
    void test_stl(map<string, list<int> >& v_)
    {
    printf(
    %s\n, __FUNCTION__);
    }
    int m_value;
    };

    class dumy_t: public foo_t
    {
    public:
    dumy_t(
    int v_):foo_t(v_)
    {
    printf(
    %s\n, __FUNCTION__);
    }
    ~dumy_t()
    {
    printf(
    %s\n, __FUNCTION__);
    }
    void dump()
    {
    printf(
    %s\n, __FUNCTION__);
    }
    };


    static foo_t obj_test(dumy_t p)
    {
    printf(
    %s\n, __FUNCTION__);
    return p;
    }

    void test_register_base_class(ffpython_t& ffpython)
    {
    ffpython.reg_class
    <foo_t, PYCTOR(int)>(foo_t
    .reg(
    &foo_t::get_value, get_value
    .reg(
    &foo_t::set_value, set_value
    .reg(
    &foo_t::test_stl, test_stl
    .reg_property(
    &foo_t::m_value, m_value);

    ffpython.reg_class
    <dumy_t, PYCTOR(int)>(dumy_tdumy_t class inherit foo_t ctor <int>foo_t
    .reg(
    &dumy_t::dump, dump);

    ffpython.reg(obj_test,
    obj_test);

    ffpython.init();
    ffpython.call
    <void>(fftesttest_register_base_class);
    };



    当c++类型被注册到python中后,python中应用该类型就像python内建的类型一样便利,须要重视的是,若是python中动态的创建了c++对象,那么他是被python的GC经管生命周期的,所以当变量不在被引用时,c++对象的析构函数被调用。对应的fftest.py中测试的脚本代码为:



    def test_register_base_class():
    
    import ext2
    foo
    = ext2.foo_t(20130426
    printtest_register_base_class get_val:, foo.get_value())
    foo.set_value(
    778899
    printtest_register_base_class get_val:, foo.get_value(), foo.m_value)
    foo.test_stl({
    key: [11,22,33] })
    printtest_register_base_class test_register_base_class, foo)



    同前边所诉的原则雷同,支撑C++ 标准内建类型和STL 泛型。当这个python函数返回时,foo_t的析构函数会被调用。


    dumy_t是foo_t的子类。应用ffpython可以便利默示两个类型的关系。若是基类已经定义的接口,子类不须要反复定义,比如要注册子类:



    ffpython.reg_class<dumy_t, PYCTOR(int)>(dumy_tdumy_t class inherit foo_t ctor <int>foo_t
    .reg(
    &dumy_t::dump, dump);

    void test_register_inherit_class(ffpython_t& ffpython)
    {
    ffpython.call
    <void>(fftesttest_register_inherit_class);
    };



    只须要零丁注册一会儿类特有的接口,其他接口主动从foo_t基类中持续而来,响应的测试python脚本代码为:



    def test_register_inherit_class():
    
    import ext2
    dumy
    = ext2.dumy_t(20130426
    printtest_register_inherit_class get_val:, dumy.get_value())
    dumy.set_value(
    778899
    printtest_register_inherit_class get_val:, dumy.get_value(), dumy.m_value)
    dumy.test_stl({
    key: [11,22,33] })
    dumy.dump()
    printtest_register_inherit_class, dumy)



    Ffpython中一个很是用用的特点是,c++创建的对象可以传递到python中,而python应用起来就像正常的python对象一样,别的python创建的c++对象也可以传递到c++中,简单示例代码:



    ffpython.reg(obj_test, obj_test);
    

    void test_cpp_obj_to_py(ffpython_t& ffpython)
    {
    foo_t tmp_foo(
    2013);
    ffpython.call
    <void>(fftesttest_cpp_obj_to_py, &tmp_foo);
    }

    void test_cpp_obj_py_obj(ffpython_t& ffpython)
    {
    dumy_t tmp_foo(
    2013);

    foo_t
    p = ffpython.call<foo_t>(fftesttest_cpp_obj_py_obj, &tmp_foo);
    }



    响应的fftest.py中的测试脚本代码为:



    def test_cpp_obj_to_py(foo):
    
    import ext2
    printtest_cpp_obj_to_py get_val:, foo.get_value())
    foo.set_value(
    778899
    printtest_cpp_obj_to_py get_val:, foo.get_value(), foo.m_value)
    foo.test_stl({
    key: [11,22,33] })
    printtest_cpp_obj_to_py test_register_base_class, foo)

    def test_cpp_obj_py_obj(dumy):
    import ext2
    printtest_cpp_obj_py_obj get_val:, dumy.get_value())
    dumy.set_value(
    778899
    printtest_cpp_obj_py_obj get_val:, dumy.get_value(), dumy.m_value)
    dumy.test_stl({
    key: [11,22,33] })
    dumy.dump()
    ext2.obj_test(dumy)
    printtest_cpp_obj_py_obj, dumy)

    return dumy



    总结:



    • l  Ffpython 支撑c++调用python函数,获取和设置模块内的变量

    • l  Ffpython call接口最多支撑9个泛型参数,支撑的类型包含c++内建的类型和STL 泛型。以及已经被注册的c++类的指针类型。返回值的类型束缚同样如此。c++ STL中的vector和list对应于python的tuple和list,map类型则对应于dict。

    • l  Ffpython支撑将c++的静态函数注册到python中。

    • l  Ffpython支撑c++类的注册,并且支撑持续。Python中操纵c++对象就像操纵原生python对象一样。

    • l  Ffpython注册的c++类在python中被创建后,将会由python GC负责收受接管内存。

    • l  Ffpython 类库只有一个文件,并且不依附其他第三方库,很是轻易集成到项目中。并且ffpython遵从开源和谈。

    • l  Ffpython应用c++模板技巧,封装了python C API的应用细节,对峙精细和简洁,效力和完全的python C API编写的代码几乎雷同。Ffpython的实现可以作为很是好的python C API的示例。

    • l  Github项目地址:https://github.com/fanchy/ffpython


    所有随风而逝的都属于昨天的,所有历经风雨留下来的才是面向未来的。—— 玛格丽特·米切尔 《飘》
    分享到: