Проверить объект в std::bind на живучесть

#include <iostream>
#include <string>
#include <functional>
using namespace std;
typedef std::function<int(string)> CALLBACK;
class Foo
{
private:
    int x = 13;
    
public:
    int callback(string str)
    {
        cout << "callback: "<< str << " " << x << endl;
        return 17;
    }
};
class A
{
private:
    CALLBACK m_callback;
 
public:
    void set_callback(CALLBACK callback)
    {
        m_callback = callback;
    }
    void call_callback()
    {
        // проверка на жизнеспособность callback'a
        
        m_callback("privet");
    }
};
 
 
 
int main()
{
    int y = 0;
    Foo* ptr = new Foo();
    A* a = new A();
 
    a->set_callback(std::bind(&Foo::callback, ptr, std::placeholders::_1));
    delete ptr;
    a->call_callback();
}

#include <iostream>
#include <string>
#include <functional>
#include <memory>
#include <map>
#include <vector>
 
struct Object
{
  virtual ~Object() {};
};
 
class Event
{
  struct SubscriptionImpl : public Object
  {
    Event* event;
 
    SubscriptionImpl(Event* e)
      : event(e)
    {
    };
 
    virtual ~SubscriptionImpl()
    {
      if (event)
      {
        event->Del(this);
      }
    }
  };
 
  friend SubscriptionImpl;
 
public:
  typedef std::function<void ()> Handler;
  typedef std::unique_ptr<Object> Subscription;
 
  Event()
  {
  }
 
  ~Event()
  {
    for (const auto p : m_handlers)
    {
      p.first->event = nullptr;
    }
  }
 
  Subscription Add(Handler handler)
  {
    std::unique_ptr<SubscriptionImpl> subscription(new SubscriptionImpl(this));
    m_handlers[subscription.get()] = handler;
    return std::move(subscription);
  }
 
  void Fire()
  {
    for (const auto p : m_handlers)
    {
      p.second();
    }
  }
 
private:
  void Del(SubscriptionImpl* subscription)
  {
    auto iter = m_handlers.find(subscription);
    if (iter != m_handlers.end())
    {
      iter->first->event = nullptr;
      m_handlers.erase(iter);
    }
  }
 
private:
  std::map<SubscriptionImpl*, Handler> m_handlers;
};
 
 
 
int main()
{
 
  std::vector<Event::Subscription> subscriptions;
 
  {
    Event e;
    subscriptions.push_back(e.Add([] {std::cout << "1" << std::endl; }));
    subscriptions.push_back(e.Add([] {std::cout << "2" << std::endl; }));
    subscriptions.push_back(e.Add([] {std::cout << "3" << std::endl; }));
 
    std::cout << "------------------" << std::endl;
    e.Fire();
 
    std::cout << "------------------" << std::endl;
    subscriptions.resize(1); // удаляем часть подписок. Отписка пройдет в деструкторах
    e.Fire();
  }
 
  // при выходе из скоупа удаление оставшихся подписок проходит безболезненно.
 
  return 0;
}