template<typename T>
class SubscriptionStorage {
public:
  struct Unsubscription {
    virtual ~Unsubscription() = default;

    virtual void unsubscribe() noexcept = 0;
  };

  [[nodiscard]]
  Unsubscription * subscribe(T && value);

  ...

private:
  struct Link {
    virtual ~Link() = default;
    Link * prev_;
    Link * next_;
  };

  struct OneSubscription : public Link, public Unsubscription {
    T payload_;
    ...
    void unsubscribe() override {
      ... // Вычеркивание из списка.
      delete this; // Уничтожение узла.
    }
  }

  Link sentinel_;
};

template<typename T>
Unsubscription * SubscriptionStorage::subscribe(T && value) {
  return new OneSubscription(std::move(value), ...);
}

-- Этот ваш C++ говно и для разработки реал-тайма не применяется!
-- А ты хоть C++ знаешь?
-- Да!
-- Что такое виртуальный деструктор?
-- Какой ты токсичный! Из-за таких как вы и C++ сообщество считается токсичным!

S> тому человеку, возможно (и скорее всего) нужно было в качестве callback-ов использовать чисто сишные функции. А это может потребоваться по разным причинам, начиная от использования легаси-кода и заканчивая интеграцией C++ного кода и кода на каком-нибудь Lua или Python (из которых наружу торчат C-шные интерфейсы).

S>template<typename T>
S>class SubscriptionStorage {
S>public:
S>  struct Unsubscription {
S>    virtual ~Unsubscription() = default;

S>    virtual void unsubscribe() noexcept = 0;
S>  };

S>  [[nodiscard]]
S>  Unsubscription * subscribe(T && value);

S>  ...

S>private:
S>  struct Link {
S>    virtual ~Link() = default;
S>    Link * prev_;
S>    Link * next_;
S>  };

S>  struct OneSubscription : public Link, public Unsubscription {
S>    T payload_;
S>    ...
S>    void unsubscribe() override {
S>      ... // Вычеркивание из списка.
S>      delete this; // Уничтожение узла.
S>    }
S>  }

S>  Link sentinel_;
S>};

S>template<typename T>
S>Unsubscription * SubscriptionStorage::subscribe(T && value) {
S>  return new OneSubscription(std::move(value), ...);
S>}
S>

SubscriptionNode[2048] nodeCache;

template<class T>
class SubscriptionStorage {
public:
  struct Subscription {
    virtual ~Subscription() = default;
  };
  using SubscriptionHandle = std::unique_ptr<Subscription>;

  [[nodiscard]]
  SubscriptionHandle subscribe(T && value);

  ... // Конструктор и прочий фарш не показаны.
private:
  struct Link {
    virtual ~Link() = default;
    Link * prev_;
    Link * next_;
  };

  struct Internals : public std::enable_shared_from_this<Internals> {
    Link sentinel_;
  };
  using InternalsShptr = std::shared_ptr<Internals>;

  struct OneSubscription : public Link, public Subscription {
    InternalsShptr internals_;
    T value_;

    OneSubscription(InternalsShptr internals, T && value)
      : internals_{std::move(internals)}, value_{std::move(value)}
    {}
    ~OneSubscription() override {
      ... // Вычеркивание себя из списка.
    }
  };

  InternalsShptr internals_;
  ...
};

template<typename T>
SubscriptionStorage<T>::SubscriptionHandle SubscriptionStorage<T>::subscribe(T && value) {
  auto result = std::make_shared<Subscription>(internals, std::move(value));
  ... // Провязывание новой подписки в список.
  return result;
}