导出函数
#include<string>
#include<boost/python.hpp>
using namespace std;
using namespace boost::python;
char const * greet()
{
return "hello,world";
}
BOOST_PYTHON_MODULE(hello_ext)
{
def("greet", greet);
}
import hello_ext
print hello_ext.greet()
导出默认构造的函数的类
#include<string>
#include<boost/python.hpp>
using namespace std;
using namespace boost::python;
struct World
{
void set(string msg) { this->msg = msg; }
string greet() { return msg; }
string msg;
};
BOOST_PYTHON_MODULE(hello) //导出的module 名字
{
class_<World>("World")
.def("greet", &World::greet)
.def("set", &World::set);
}
import hello
planet = hello.World() # 调用默认构造函数,产生类对象
planet.set("howdy") # 调用对象的方法
print planet.greet() # 调用对象的方法
构造函数的导出:
#include<string>
#include<boost/python.hpp>
using namespace std;
using namespace boost::python;
struct World
{
World(string msg):msg(msg){} //增加构造函数
World(double a, double b):a(a),b(b) {} //另外一个构造函数
void set(string msg) { this->msg = msg; }
string greet() { return msg; }
double sum_s() { return a + b; }
string msg;
double a;
double b;
};
BOOST_PYTHON_MODULE(hello) //导出的module 名字
{
class_<World>("World",init<string>())
.def(init<double,double>()) // expose another construct
.def("greet", &World::greet)
.def("set", &World::set)
.def("sum_s", &World::sum_s);
}
import hello
planet = hello.World(5,6)
planet2 = hello.World("hollo world")
print planet.sum_s()
print planet2.greet()
如果不想导出任何构造函数,则使用no_init:
class_<Abstract>("Abstract",no_init)
类的数据成员
#include<string>
#include<boost/python.hpp>
using namespace std;
using namespace boost::python;
struct Var
{
Var(string name):name(name),value(){}
string const name;
float value;
};
BOOST_PYTHON_MODULE(hello_var)
{
class_<Var>("Var", init<string>())
.def_readonly("name", &Var::name) //只读
.def_readwrite("value", &Var::value); //读写
}
import hello_var
var = hello_var.Var("hello_var")
var.value = 3.14
# var.name = 'hello' # error
print var.name
类的属性
// 类的属性
#include<string>
#include<boost/python.hpp>
using namespace std;
using namespace boost::python;
struct Num
{
Num(){}
float get() const { return val; }
void set(float val) { this->val = val; }
float val;
};
BOOST_PYTHON_MODULE(hello_num)
{
class_<Num>("Num")
.add_property("rovalue", &Num::get) // 对外:只读
.add_property("value", &Num::get, &Num::set);// 对外读写 .value值会改变.rovalue值,存储着同样的数据。
}
import hello_num
num = hello_num.Num()
num.value = 10
print num.rovalue # result: 10
继承
// 类的继承
#include<string>
#include<iostream>
#include<boost/python.hpp>
using namespace std;
using namespace boost::python;
struct Base {
virtual ~Base() {};
virtual string getName() { return "Base"; }
string str;
};
struct Derived : Base {
string getName() { return "Derived"; }
};
void b(Base *base) { cout << base->getName() << endl; };
void d(Derived *derived) { cout << derived->getName() << endl; };
Base * factory() { return new Derived; }
/*
下面的额外的代码如果去掉会报错。
解决地址:http://stackoverflow.com/questions/38261530/unresolved-external-symbols-since-visual-studio-2015-update-3-boost-python-link/38291152#38291152
*/
namespace boost
{
template <>
Base const volatile * get_pointer<class Base const volatile >(
class Base const volatile *c)
{
return c;
}
}
BOOST_PYTHON_MODULE(hello_derived)
{
class_<Base>("Base")
.def("getName", &Base::getName)
.def_readwrite("str", &Base::str);
class_<Derived, bases<Base> >("Derived")
.def("getName", &Derived::getName)
.def_readwrite("str", &Derived::str);
def("b", b);
def("d", d);
def("factory", factory,
return_value_policy<manage_new_object>());//
}
import hello_derived
derive = hello_derived.factory()
hello_derived.d(derive)
类的虚函数:
/*
类的虚函数,实现的功能是:可以编写Python类,来继承C++类
*/
#include<boost/python.hpp>
#include<boost/python/wrapper.hpp>
#include<string>
#include<iostream>
using namespace boost::python;
using namespace std;
struct Base
{
virtual ~Base() {}
virtual int f() { return 0; };
};
struct BaseWrap : Base, wrapper<Base>
{
int f()
{
if (override f = this->get_override("f"))
return f(); //如果函数进行重载了,则返回重载的
return Base::f(); //否则返回基类
}
int default_f() { return this->Base::f(); }
};
BOOST_PYTHON_MODULE(hello_virtual)
{
class_<BaseWrap, boost::noncopyable>("Base")
.def("f", &Base::f, &BaseWrap::default_f);
}
import hello_virtual
base = hello_virtual.Base()
# 定义派生类,继承C++类
class Derived(hello_virtual.Base):
def f(self):
return 42
derived = Derived()
print base.f()
print derived.f()