Question: typedef bool (*ftype_callback)(ClientInterface* client, const Member* member ,int member_num); struct Member{ char x[64]; int y; }; class ClientInterface { public: virtual int calc()=0; virtual bool join()=0; virtual bool set_callback(ftype_callback on_member_join)=0; };  It is from SDK which I can call the client from dynamic library in c++ codes. bool cb(ClientInterface* client, const Member* member ,int member_num) { // do something } cli->set_callback(cb); cli->join();  I want to port it to python bindings use pybind11. How do I set_callback in python? I have seen the doc and try: PYBIND11_MODULE(xxx, m) { m.def("set_callback", [](xxx &self, py::function cb ){ self.set_callback(cb); }); }  The code just failed to compile. My question, how do I convert the py::function to ftype_callback or there is other way to make it?

Answer: You need a little C++ to get things going. I'm going to use a simpler structure to make the answer more readable. In your binding code: #include <pybind11/pybind11.h> #include <functional> #include <string> namespace py = pybind11; struct Foo { int i; float f; std::string s; }; struct Bar { std::function<bool(const Foo &foo)> python_handler; std::function<bool(const Foo *foo)> cxx_handler; Bar() { cxx_handler = [this](const Foo *foo) { return python_handler(*foo); }; } }; PYBIND11_MODULE(example, m) { py::class_<Foo>(m, "Foo") // .def_readwrite("i", &Foo::i) .def_readwrite("f", &Foo::f) .def_readwrite("s", &Foo::i); py::class_<Bar>(m, "Bar") // .def_readwrite("handler", &Bar::python_handler); }  Here, Foo is the object that is passed to the callback, and Bar is the object that needs its callback function set. Since you use pointers, I have wrapped the python_handler function with cxx_handler that is meant to be used in C++, and converted the pointer to reference. To be complete, I'll give a possible example of usage of the module here: import module.example as impl class Bar: def __init__(self): self.bar = impl.Bar() self.bar.handler = self.handler def handler(self, foo): print(foo) return True  I have used this structure successfully in one of my projects. I don't know how you want to proceed, but perhaps if you don't want to change your original structure you can write wrapper classes upon them that use the given structure. Update: I thought that you controlled the structure when I wrote the answer above (I'll keep it for anyone who needs it). If you have a single cli instance, you can do something like: using Handler = std::function<bool(std::string, int, int)>; Handler handler; bool cb(ClientInterface *client, const Member *member, int member_num) { return handler(std::string(member->x), member->y, member_num); } // We have created cli somehow // cli->set_callback(cb); // cli->join(); PYBIND11_MODULE(example, m) { m.def("set_callback", [](Handler h) { handler = h; }); }  If you have multiple ClientInterface instances, you can map ClientInterface pointers to handlers and call the appropriate handler in the cb function based on given ClientInterface pointer. Note: I haven't tested the above with a python script but it should work. Another Update If you want to handle multiple instances, the code can roughly look like this: using Handler = std::function<bool(std::string, int, int)>; std::map<ClientInterface *, handler> map; bool cb(ClientInterface *client, const Member *member, int member_num) { // Check if <client> instance exists in map return map[client](std::string(member->x), member->y, member_num); } PYBIND11_MODULE(example, m) { m.def("set_callback", [](int clientid, Handler h) { // Somehow map <clientid> to <client> pointer map[client] = h; }); }  Note that this isn't a runnable code and you need to complete it.