Boost-python Select Between Overloaded Methods

Assume exist some class Foo with two overloaded methods: class Foo { ... void m1(A& a); void m1(B& b); I need expose one of these methods over boost-python: boost:

Solution 1:

Just for completion, it is also possible to have both of them exposed at python side:

void (Foo::*m1_a)(A&) = &Foo::m1;
void (Foo::*m1_b)(B&) = &Foo::m1;

boost::python::class_<Foo>("Foo")
    .def("m1", m1_a)
    .def("m1", m1_b)

Solution 2:

void (Foo::*m1)(A&) = &Foo::m1;
boost::python::class_<Foo>("Foo")
    .def("m1", m1)

Solution 3:

While the other answers are correct there is no need to do any shenanigans with temporary variables or static_cast.

The def function prototypes look like this:

template <classFn>
class_& def(charconst* name, Fn fn);
template <classFn, classA1>
class_& def(charconst* name, Fn fn, A1 const&);
template <classFn, classA1, classA2>
class_& def(charconst* name, Fn fn, A1 const&, A2 const&);
template <classFn, classA1, classA2, classA3>
class_& def(charconst* name, Fn fn, A1 const&, A2 const&, A3 const&);

As you can see the first template parameter (Fn) is the type of the function pointer you want to wrap. Usually, all the template parameters are deduced by the compiler for you. However, if there is an ambiguity you need to help the compiler. If the function pointer is ambiguous due to an overloaded function you have to provide the proper type explicitly. In your case:

boost::python::class_<Foo>("Foo")
    .def<void (Foo::*)(A&)>("m1", &Foo::m1)
    .def<void (Foo::*)(B&)>("m1", &Foo::m1)
    ;

Simple, isn't it? No need to cast or capture outside. The same thing is valid for creating free standing function at the module level, i.e. using boost::python::def.

Solution 4:

You can use static_cast to specify which signature to use. With this method, you do not need to create a named function pointer while also keeping your overload resolution within the context of a single line.

boost::python::class_<Foo>("Foo")
    .def("m1", static_cast<void (Foo::*)(A&)>(&Foo::m1))
    .def("m1", static_cast<void (Foo::*)(B&)>(&Foo::m1))