具有不同所有者的 std::enable_shared_from_this

Question

还有另一个 enable_shared_from_this 问题：基本上，我得到了三件事。

1. 系统类包含应用程序逻辑，可能是也可能不是事件监听器。
2. 某种 EventManager，将事件映射到感兴趣系统的 shared_ptrs。
3. 某种 SystemManager，它持有一个 std::list 的 shared_ptrs 到 System 对象。

现在，每个系统都应该能够向 EventManager 注册它感兴趣的各种事件。此外，如果它们不再对这些事件感兴趣，它们应该能够注销自己的这些事件.

但是，我不确定如何在系统管理器中创建系统并以避免两个所有权组的方式进行注册。

来自 SystemManager：

void SystemManager::AddSystem(GameSystem* system)
{
    // Take ownership of the specified system.
    systems.push_back(std::shared_ptr<GameSystem>(system));
}

来自事件管理器：

typedef std::shared_ptr<IEventListener> EventListenerPtr;

void EventManager::AddListener(EventListenerPtr const & listener, HashedString const & eventType)
{
    // Get the event type entry in the listeners map.
    std::map<unsigned long, std::list<EventListenerPtr>>::iterator iterator = this->listeners.find(eventType.getHash());

    if (iterator != this->listeners.end())
    {
        std::list<EventListenerPtr> & eventListeners = iterator->second;

        // Add listener.
        eventListeners.push_back(listener);
    }
    else
    {
        // Add new entry to listeners map, removed for sake of simplicity of this example.
    }
}

来自某个想要接收事件的任意系统：

void RenderSystem::InitSystem(std::shared_ptr<GameInfrastructure> game)
{
    // BAD: Creates second ownership group.
    this->game->eventManager->AddListener(std::shared_ptr<IEventListener>(this), AppWindowChangedEvent::AppWindowChangedEventType);
}

我已阅读推荐 enable_shared_from_this 的参考资料。但是，由于系统不拥有自己，因此它们无权访问最初创建系统并取得系统所有权的 SystemManager 持有的 shared_ptr。

有什么优雅的方法可以解决这个问题吗？

Answer 1

您的第一个问题是IEventListener。我猜它是一个简单回调的接口。

不要对简单回调的接口使用继承，对简单回调使用类型擦除。

typedef std::function<void(EventData)> EventListener;
typedef std::weak_ptr<EventListener> wpEventListener;
typedef std::shared_ptr<EventListener> EventToken;

EventToken EventManager::AddListener(EventListener listener, HashedString const & eventType)
{
  // note type changes (3 of them!) -- change the type of this->listeners to match
  // probably HashedString should have a std::hash<HashedString> specialization to make this
  // less painful
  // also should be auto iterator = -- the type of an iterator is not interesting.
  std::unordered_map<unsigned long, std::vector<wpEventListener>>::iterator iterator = this->listeners.find(eventType.getHash());

  if (iterator != this->listeners.end())
  {
    auto & eventListeners = iterator->second;

    EventToken retval = std::make_shared<EventListener>(std::move(listener));
    eventListeners.push_back(retval);
    return retval;
  } else {
    // Add new entry to listeners map, removed for sake of simplicity of this example.
  }
}

现在，当您安装 Listener 时，您有责任保留您的 EventToken，直到您不再想收听它。不想听的时候，EventToken.reset()。

在EventManager 中，当您迭代收听的人时，执行auto listener = it->lock(); if (!listener) continue;，此外还执行快速erase-remove-if 以删除已死的weak_ptrs。

现在我们的EventManager 不拥有其听众的生命周期，他们可以（几乎）随时离开。 EventManager 会在下次调用事件时发出通知，并清除已死的事件。

您可以将其改造成使用IEventListener，但即使在这里您也需要弱指针，而不是共享指针。到处使用共享指针会给你带来麻烦，因为你会有大量的循环自支持引用和资源泄漏。

最后，shared_from_this 实际上允许您访问拥有您的shared_ptr。这意味着当shared_ptr被构造时，weak_ptr被存储在shared_from_this中，即使你只有this指针，以后也可以提取。

我通常认为这是一个不好的迹象：您应该很少在随机上下文中将原始指针升级为共享指针。方法的生命周期语义从其接口应该是显而易见的，并且将 T* 内部转换为 shared_ptr<T> 会使生命周期语义完全不清楚。