boost-python select between overloaded methods

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)

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

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 <class Fn>class_& def(char const* name, Fn fn);template <class Fn, class A1>class_& def(char const* name, Fn fn, A1 const&);template <class Fn, class A1, class A2>class_& def(char const* name, Fn fn, A1 const&, A2 const&);template <class Fn, class A1, class A2, class A3>class_& def(char const* 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.