Callback class to callback member (virtual) functions
Overall, the design looks reasonable.  However, I can't shake the feeling that Lambda expressions are a good (maybe even better) fit here.

For example, instead of

member_callback(object, &amp;integer::--);


you could use a Lambda expression:

[&amp;] () { return object--; }


This is almost as short, and has some additional advantages:


You aren't effectively "reinventing the wheel".  Although I wouldn't say your member_callback class is precisely the same as a lambda, it's pretty close.
I'm not qualified to say whether your code conforms to the C++ 11 specification.  But assuming it does, you are relying on relatively obscure portions of the specification.  This has some practical problems:


Others might have a hard time understanding and verifying your code.
Compilers often don't conform as strictly to the spec as we would like.  So you might find that your code is not portable, even if it does conform the the spec.

You noted that one of the drawbacks of your approach is that you cannot mix functions to different types of objects.  With lambdas, you can combine functions that work on different types of objects.  You aren't just limited to objects of a single (base) type (in your case, integer).  Likewise, you can define functions that operate on more than one object, or even none at all (e.g., produce a constant value).  Or, you could combine functions.
Lambdas open the door to higher-order approaches.  For example, if you Curry the member_callback function, you can partially instantiate a callback:


With the order you have (object, function), you can construct a factory for working on a single object.  For example (eliding types for brevity):

factory = member_callback_curried(object);

// Sometime later, perhaps in a different scope
dec = factory([] (integer&amp; obj) { return obj--; });
inc = factory([] (integer&amp; obj) { return obj++; });

Reversing the order to (function, object), you can construct a factory for working with the specified function:

factory = callback_member_curried([&amp;] (integer&amp; obj) { return obj-- });

// Sometime later, perhaps in a different scope
dec_o1 = factory(obj1); // function that decrements obj1
dec_o2 = factory(obj2); // function that decrements obj2