How to bind one of member functions of the same name in a class, with c++11 std::bind

Why don't skip std::bind altogether and use a lambda?

auto fp = [&t]() { t.test()};

As a bonus, your executable size will be smaller and your compiler has much easier time to inline the code if appropriate.

By casting it to the correct type:

std::function<void()> f = std::bind( static_cast<int (Test::*)()>(&Test::work), &test);

When deducing the template arguments to bind, the compiler is not in a context that allows function overload resolution - to be simplistic about it, it hasn't got that far yet.

Having deduced that the first argument is indeed the name of a member function pointer, it finds that there are two functions of the same name but of different types.

At this stage, they're both equally valid candidates (from the point of template argument deduction), therefore it's ambiguous

A static cast disambiguates because we're pushing the compiler beyond the stage where it has to deduce a template type - we have taken on the responsibility to template type deduction ourselves - by specifying the type in the static_cast.

So now all it has to do is overload resolution.

#include <functional>
#include <thread>
#include <iostream>

using namespace std;

class Test{
public:

    int work(){
        cout << "in work " << endl;
        return 0;
    }

    void work(int x){
        //cout << "x = " << x << endl;
        cout << "in work..." << endl;
    }
};

int main(){
    Test test;

    // only overload resolution required here 
    auto fp = static_cast<int (Test::*)()>(&Test::work);

    // type is now unambiguous and overload resolution is already done
    std::function<void()> f = std::bind(fp, &test);

    thread th(f);
    th.join();
    return 0;
}