How to make constructor accept method callbacks

Say I have

class Foo
{
public:
    Foo(std::function<void(std::string)> callback1,
        std::function<void(int)> callback2) :
        callback1(callback1), callback2(callback2)
    {
    }

private:
    std::function<void(std::string)> callback1;
    std::function<void(int)> callback2
}

I can easily construct it in the case I'm using plain functions

void callback1Handler(std::string)
{
    // i'm a potato
}

void callback2Handler(int)
{
    // i'm a teapot
}

int main()
{
    Foo foo(callback1Handler, callback2Handler);

    return 0;
}

But if I'm using a class, then things get complicated.

I'd like to be able to do something like the Addendum of this answer does

class Main
{
public:
    Main()
    {
        Foo foo(&Main::callback1Handler, &Main::callback2Handler);
    }

    void callback1Handler(std::string)
    {
        // i'm a potato
    }

    void callback2Handler(int)
    {
        // i'm a teapot
    }
}

But that obviously wouldn't compile. To make it work one would need to use either std::bind or lambdas, or something else.

I want to try to avoid the ugliness of std::bind(&Main::callbackNHandler, this, std::placeholders::_1, ..., std::placeholders::_N), which is mostly the ugliness of having those placeholders explicitly specified.

Using lambdas as [=](std::string str){callbackNHandler(str);} is also ugly, because you have to specify every single variable the callback accepts.

It would be great if I could just use &Main::callback1Handler, just like in the Main class example, or &Main::callback1Handler, this, which is a bit more flexible, since you can specify the instance pointer of Main.

Note that Foo constructor has to remain the same and callback1&callback2 member variables have to also remain the same. However, you may overload Foo constructor, making the overload convert method pointers (or whatever else you will make it to accept) into std::functions and store them in callback1&callback2.