Блог

До C 17

Я хотел бы убедиться, что объект является живым на время выполнения его обратных вызовов.

Это был важный момент. Рассмотрим функцию обратного вызова, которая запрашивает данные от объекта, передающего обратный вызов. Теперь я хочу сохранить излучающий объект живым до тех пор, пока указанная функция обратного вызова не получит то, что ей нужно. Это может быть не для всех обратных вызовов, не все обратные вызовы имеют дело с объектами, которые могут быть удалены в следующий раз.

Это то, что я придумал. Используя идиому именованного конструктора, я могу убедиться, что созданный объект является shared_ptr , а затем я могу использовать для этого weak_ptr и так далее.

Интересно, есть ли лучший способ обойти это?

 // Example program
#include <memory>
#include <functional>
#include <iostream>

class Callback
{
public:
  using t_callback_func = std::function<void(std::shared_ptr < Callback>)>;
  using t_shared = std::shared_ptr<Callback>;
  std::vector<t_callback_func> callbacks;
  std::weak_ptr<Callback> uglyhax;

  static std::shared_ptr<Callback> make()
  {
    auto shared = std::shared_ptr<Callback>(new Callback());
    shared->uglyhax = shared;
    return shared; 
  }

  void register_callback(std::function<void(std::shared_ptr<Callback>)> amp;amp; p_callback)
  {
    callbacks.emplace_back(std::forward<t_callback_func>(p_callback));
  }

  void notify()
  {
    if (auto shared = uglyhax.lock())
    {
      for (auto amp; callback : callbacks)
      {
        callback(shared);
      }
    }
  }

  void remove_callbacks()
  {
    callbacks.clear();
  }

  void hello()
  {
    std::cout << "hello " << this << "n";
  }

  ~Callback() { std::cout << "dtor  " << this << "n"; }

protected:
  Callback() { std::cout << "ctor " << this << "n"; }

};

class EventList
{
  std::vector<std::function<void()>> events;
public:
  void call_events()
  {
    for (autoamp; event : events)
    {
      event();
    }
    events.clear();
  }

  template<class ...Args>
  auto wrap_as_event(std::function<void(Args...)> amp;amp; p_func)
  {
    return [this, p_func](Args... args)
    {
      std::cout << "adding eventn";
      this->events.emplace_back(std::move(std::bind(std::move(p_func), std::forward<Args>(args)...)));
    };
  }
};

int main()
{
  EventList list;
  {
    {
      auto thing = Callback::make(); // I want to keep the thing allocated here alive until all its callbacks have been processed
      std::function<void(Callback::t_shared)> function = [](Callback::t_shared ptr) {ptr->hello(); ptr->remove_callbacks(); };
      thing->register_callback(list.wrap_as_event(std::move(function)));
      thing->notify();
    }
    std::cout << "dtor should be called after thisn";
    list.call_events();
  }
  std::cout << "dtor should be called before thisn";
}
 

Вывод:

 ctor 013E81C0
adding event
dtor should be called after this
hello 013E81C0
dtor  013E81C0
dtor should be called before this
 

Вы можете отделить логику выполнения события от события и объекта полезной нагрузки события.

Это Callable наследование enable_shared_from_this<Callable> , которое позволяет безопасно создавать дополнительные shared_ptr . Заводской метод getCallable создаст экземпляр Callable в куче, что является необходимым условием для enible_shared_from_this работы.

Callable Класс знает, как генерировать события и как зарегистрировать их shared_ptr в CallableEvent специализированном классе Event . Затем Event он отправляется на EventHandler который будет обрабатывать событие.

 // Example program
#include <memory>
#include <functional>
#include <iostream>
#include <vector>

class Event;
class Callable;
class CallableEvent;

class Event {
public:
    virtual void trigger();
};

class EventHandler {
public:
    std::vector<std::shared_ptr<Event>> eventList;
    static EventHandleramp; getInstance() {
        static EventHandler instance = EventHandler();
        return instance;
    }

    void registerEvent(std::shared_ptr<Event> event) {
        eventList.push_back(event);
    }

    void processEvents() {
        for (auto event : eventList) {
            event->trigger();
        }
    }
};

class CallableEvent : public Event, public std::enable_shared_from_this<CallableEvent> {
public:
    using t_callback = std::function<void(std::shared_ptr<Callable>)>;
    std::shared_ptr<Callable> callable;
    t_callback callback;

    void trigger() override;

    CallableEvent() { std::cout << "Callable Event Created " << this << "n"; }
    ~CallableEvent() { std::cout << "Callable Event Destroyed " << this << "n"; }
};

class Callable : public std::enable_shared_from_this<Callable> {
public:
    int _payload;
    void registerEvent(std::function<void(std::shared_ptr<Callable>)> lambda) {
        std::shared_ptr<CallableEvent> ev = std::shared_ptr<CallableEvent>(new CallableEvent());
        ev->callable = shared_from_this();
        ev->callback = std::move(lambda);
        EventHandler::getInstance().registerEvent(ev);
    }

    static std::shared_ptr<Callable> createCallable(int payload) {
        return std::shared_ptr<Callable>(new Callable(payload));
    }

    void sayThis() {
        std::cout << "Hello from Callable "<< this << " my payload is " << _payload << "n";
    }

    ~Callable() {
        std::cout << "Callable destroyed " << this << " with payload " << _payload << "n";
    }

private:
    Callable(int payload) {
        _payload = payload;
        std::cout << "Callable created " << this << " with payload " << _payload << "n";
    }
};

void Event::trigger() {
    std::cout << "generic event n";
}

void CallableEvent::trigger() {
    callback(callable);
}

int main()
{
    {
        {
            auto cb = Callable::createCallable(15);
            CallableEvent::t_callback function = [](std::shared_ptr<Callable> ptr) {
                std::cout << "Calling from lambdan";
                ptr->sayThis();
            };
            cb->registerEvent(function);
        }
        std::cout << "Callback should be called after thisn";
        EventHandler::getInstance().processEvents();
  }
  std::cout << "Callback should be called before thisn";
}
 

При запуске примера выводится следующий вывод:

 Callable created 0x7f89f4c057d0 with payload 15
Callable Event Created 0x7f89f4c05810
Callback should be called after this
Calling from lambda
Hello from Callable 0x7f89f4c057d0 my payload is 15
Callback should be called before this
Callable Event Destroyed 0x7f89f4c05810
Callable destroyed 0x7f89f4c057d0 with payload 15

Process finished with exit code 0
 

Теперь вы можете переместить обработчик в другой поток, и события будут выполняться асинхронно.