-
- l 主系十足应用C++实现，对峙体系的高效。
- l 把握项目组应用python，增长开辟效力，python的内存垃圾收受接管，雄厚的类库都使C++开辟者获益匪浅。
- l Python脚本可以运行期重载，可以实现把握项目组不绝机热更新。
- 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中。
- 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
C++应用ffpython嵌入和扩大python
添加时间:2013-5-9 点击量:择要:
在办事器编程中，经常会用到python脚本技巧。Python是最风行的脚本之一，并且python拥有定义杰出的C API接口，同时又有雄厚的文档，与C++连络很是的合适。凡是景象下应用C++封装机制，而用python脚本实现策略或者是把握。应用python和C++连络的技巧拥有如下上风：
C++与python的编程范式有很大不合，当应用python C API调用python时，python中的一些特有机制会给C++开辟者带来很多困惑。经常应用python C API时须要重视如下几点:
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>（sys， version）.c_str（））;
上方的代码获取python标准库中sys的version变量值，ffpython经由过程模板函数的主动将python的str类型主动适配到c++的string类型。get_global_var是获取变量的接口，与之对应的是设置变量的借口get_global_var：
ffpython.get_global_var（fftest， global_var， OhNice）;
printf（fftest.global_var=％s\n， ffpython.get_global_var<string>（fftest， global_var）.c_str（））;
调用python函数是嵌入python非经常用的操纵，ffpython中供给了call接口用于调用python中的module的函数：
printf（time.asctime=％s\n， ffpython.call<string>（time， asctime）.c_str（））;
上方的代码调用time模块的asctime办法，我们也可以应用call接口调用我们本身编写的函数：
int a1 = 100; float a2 = 3.14f; string a3 = OhWell;
ffpython.call<void>（fftest， test_base， a1， a2， a3）;
Call被定义为模版函数，传入的参数会主动适配到python响应的类型。对应的python函数为：
def test_base（a1， a2， a3）:
print（test_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>（fftest， test_stl， a1， a2， a3）;
}
对应调用的python函数为：
def test_stl（a1， a2， a3）:
print（test_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>（fftest， test_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（）
print（test_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_t， dumy_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>（fftest， test_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）
print（test_register_base_class get_val:， foo.get_value（））
foo.set_value（778899）
print（test_register_base_class get_val:， foo.get_value（）， foo.m_value）
foo.test_stl（{key: [11，22，33] }）
print（test_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_t， dumy_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>（fftest， test_register_inherit_class）;
};
只须要零丁注册一会儿类特有的接口，其他接口主动从foo_t基类中持续而来，响应的测试python脚本代码为：
def test_register_inherit_class（）:
import ext2
dumy = ext2.dumy_t（20130426）
print（test_register_inherit_class get_val:， dumy.get_value（））
dumy.set_value（778899）
print（test_register_inherit_class get_val:， dumy.get_value（）， dumy.m_value）
dumy.test_stl（{key: [11，22，33] }）
dumy.dump（）
print（test_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>（fftest， test_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>（fftest， test_cpp_obj_py_obj， &tmp_foo）;
}
响应的fftest.py中的测试脚本代码为：
def test_cpp_obj_to_py（foo）:
import ext2
print（test_cpp_obj_to_py get_val:， foo.get_value（））
foo.set_value（778899）
print（test_cpp_obj_to_py get_val:， foo.get_value（）， foo.m_value）
foo.test_stl（{key: [11，22，33] }）
print（test_cpp_obj_to_py test_register_base_class， foo）
def test_cpp_obj_py_obj（dumy）:
import ext2
print（test_cpp_obj_py_obj get_val:， dumy.get_value（））
dumy.set_value（778899）
print（test_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）
print（test_cpp_obj_py_obj， dumy）
return dumy
总结：
所有随风而逝的都属于昨天的，所有历经风雨留下来的才是面向未来的。—— 玛格丽特·米切尔 《飘》
