Invoking member of an object from another one by using `std::function`

Question 1

Looking at your code, it looks like you would be better off storing std::function<double(double, int)>, and then use std::bind to bind the objects to the member functions.

template <typename F>
void AddSubscriber( const Callable & obj,
                    F subscriber)
{
    Subscribers.push_back(std::bind(subscriber, obj, _1, _2));
}

Or just de-couple Callable from Caller completely, by passing something convertible to std::function<double(double, int)> directly:

class Caller 
{
public:
  template <typename F>
  void AddSubscriber(F&& subscriber)
  {
     subscribers.emplace_back(std::forward<F>(subscriber));
  }
  void CallSubscribers()
  {
      for (const auto& subscriber : subscribers)
      {
          subscriber(1.0, 2);
      }
  }
 private:
  std::vector<std::function<double(double, int)> subscribers;
};

and then do the binding from the caller side.

Caller c;
ClassA a;
using namespace std::placeholders;
c.AddSubscriber(std::bind(&ClassA::CallThis, a, _1, _2));

Question 2

After reading juanchopanza's answer, I rewrote my code as attached below. Now it works as expected.

class ClassA
{
    public:
        double CallThis(double x, int y) const
        {
            MessageBoxW(NULL, L"CallThis() is called.", L"In ClassA", MB_ICONINFORMATION);
            return x + y;
        }
};

class ClassB
{
    public:
        double CallMe(double x, int y) const
        {
            MessageBoxW(NULL, L"CallMe() is called.", L"In ClassB", MB_ICONINFORMATION);
            return x + y;
        }
};

class Caller
{
    public:
        void AddSubscriber(std::function<double(double, int)> Subscriber)
        {
            Subscribers.push_back(Subscriber);
        }
        void CallSubscribers()
        {
            for (const auto & Subscriber : Subscribers)
            {
                Subscriber(1.0, 2);
            }
        }
    private:
        std::vector<std::function<double(double, int)>> Subscribers;
};

int APIENTRY wWinMain(  _In_        HINSTANCE   hInstance,
                        _In_opt_    HINSTANCE   hPrevInstance,
                        _In_        LPTSTR      lpCmdLine,
                        _In_        int         nCmdShow)
{
    // ...

    ClassA ObjectA;
    ClassB ObjectB;
    Caller ObjectCaller;
    ObjectCaller.AddSubscriber(std::bind(&ClassA::CallThis, ObjectA, std::placeholders::_1, std::placeholders::_2));
    ObjectCaller.AddSubscriber(std::bind(&ClassB::CallMe,   ObjectB, std::placeholders::_1, std::placeholders::_2));
    Sleep(5000);
    ObjectCaller.CallSubscribers();

    // ...
}