我认为根据C++11标准，这应该是支持的
实际上不是，因为非静态成员函数有一个隐式的第一个参数类型（cv限定）YourType*，所以在这种情况下它不匹配void(int)。因此需要std::bind：

Register(std::bind(&Class::Function, PointerToSomeInstanceOfClass, _1));

比如说，

Class c;
using namespace std::placeholders; // for _1, _2 etc.
c.Register(std::bind(&Class::Function, &c, _1));

编辑您提到这是要用同一个Class示例调用的。在这种情况下，你可以使用一个简单的非成员函数：

void foo(int n)
{
  theClassInstance.Function(n);
}

然后

Class c;
c.Register(foo);

根据Stephan T. Lavavej -“避免使用bind（），...，使用lambdas”。https://www.youtube.com/watch?v=zt7ThwVfap0&t=32m20s
在这种情况下：

Class()
{
    Register([this](int n){ Function(n); });
}

可以使用std::bind：

using namespace std::placeholders;  // For _1 in the bind call
// ...
Register(std::bind(&Class::Function, this, _1));

在C++ 17中，你可以用途：

Register([=](auto && ...args){ return Function(args...); });

这是甜蜜的，特别是如果参数列表更长。当然成员函数的参数列表必须与std::function的参数列表兼容。

使用std::function和std::bind，可以将不同的类成员函数视为相同的。

#include <iostream>
#include <functional>
#include <vector>
using namespace std;
using namespace std::placeholders;
class Foo
{
public:
    void foo(const string &msg)
    {
        cout << msg << '\n';
    }
};
class Bar
{
public:
    void bar(const string &msg, const string &suffix)
    {
        cout << msg << suffix << '\n';
    }
};
int main(int argc, char **argv)
{
    Foo foo;
    Bar bar;
    vector<function<void (const string &msg)>> collection;
    collection.push_back(bind(&Foo::foo, &foo, _1));
    collection.push_back(bind(&Bar::bar, &bar, _1, "bar"));
    for (auto f : collection) {
        f("foo");
    }
    return 0;
}

正如其他人已经说过的，您可以使用std::bind。语法是相当丑陋的。因此，我提供这些宏：

#define bindToThis( className, funcName ) \
    std::bind( &className::funcName, this, std::placeholders::_1 )
#define bindToThat( className, funcName, objPtr ) \
    std::bind( &className::funcName, objPtr, std::placeholders::_1 )

下面是宏的一个示例实现，在第一次键入std::function以定义所需的签名（这也使其更容易阅读/使用）之后：

typedef std::function<void(const int)> MyIntHandler;
class MyClass 
{
public:
    MyClass( const MyIntHandler handler );
};
...
SomeOtherClass::SomeOtherClass() 
    : myObjPtr_( new MyClass( 
        MyIntHandler( bindToThis( SomeOtherClass, handleSomeInt ) ) )
{}
void SomeOtherClass::handleSomeInt( const int i )
{
    // Do something...
}