C++ weak_ptr.lock() segfault

Question

所以我有这个函数来添加侦听器，它转换类的共享指针，以便稍后收到通知时可以调用它。

void registerListener(std::shared_ptr<T> listener)
{
    if (!listener) {
        qCWarning(OBSERVER_LOGGER) << "Attempted to register a null observer.";
        return;
    }
    // TODO make a foreach function that removes dead listeners to get rid of this code dupe
    for (auto iter=listeners.begin(); iter != listeners.end(); ) {
        if (auto shared = iter->lock()) {
            if (listener == shared) {
                return;
            }
            iter++;
        } else {
            iter = listeners.erase(iter);
        }
    }
    auto weak = std::weak_ptr<T>(listener);
    listeners.push_back(weak);
}
void notify(std::function<void(std::shared_ptr<T>)> onNotify)
{
    // TODO make a foreach function that removes dead listeners to get rid of this code dupe
    for (auto iter=listeners.begin(); iter != listeners.end(); ) {
        if (auto shared = iter->lock()) {
            onNotify(shared);
            iter++;
        } else {
            iter = listeners.erase(iter);
        }
    }
}
private:
std::vector<std::weak_ptr<T>> listeners;

由于某种原因，"iter->lock（）"segfault。我会说这是一个Qt应用程序，但我故意没有创建任何线程（据我所知），所以我非常困惑我做错了什么，让这些weak_ptr崩溃。所以，如果我在gdb中运行它，它运行得很好。但如果我设置"设置禁用随机化关闭"，那么我会得到错误。所以我觉得这是一个未初始化变量的奇怪问题。如果有帮助的话，这就是我在gdb中崩溃时的堆栈。

#0  0x00007f856bd8beec in std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_get_use_count() const ()
#1  0x00007f856bd844a8 in std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_add_ref_lock_nothrow() ()
#2  0x00007f856bd9cd7d in std::__shared_count<(__gnu_cxx::_Lock_policy)2>::__shared_count(std::__weak_count<(__gnu_cxx::_Lock_policy)2> const&, std::nothrow_t) ()
#3  0x00007f856bda9948 in std::__shared_ptr<IEntityListener<Assignment>, (__gnu_cxx::_Lock_policy)2>::__shared_ptr(std::__weak_ptr<IEntityListener<Assignment>, (__gnu_cxx::_Lock_policy)2> const&, std::nothrow_t) ()
#4  0x00007f856bda8a62 in std::shared_ptr<IEntityListener<Assignment> >::shared_ptr(std::weak_ptr<IEntityListener<Assignment> > const&, std::nothrow_t) ()
#5  0x00007f856bda701a in std::weak_ptr<IEntityListener<Assignment> >::lock() const ()
#6  0x00007f856bda5624 in Observer<IEntityListener<Assignment> >::notify(std::function<void (std::shared_ptr<IEntityListener<Assignment> >)>) ()
#7  0x00007f856bda3a1a in EntityObserver<Assignment>::notifyCreated(std::shared_ptr<Assignment>) ()

编辑：Michael Burr发布了听众注册的可能性，而新听众则被添加，这完全可能发生。这将导致迭代器无效，当我在一段不是weak_ptr的内存上调用weak_ptr.lock（）时，BOOM。我认为这里有一个寓意，我必须找到它。

Answer 1

当调用notify()时，通过onNotify()函数对象调用的函数是否可能导致间接调用registerListener()（或其他可以添加或删除listeners集合中的项的代码）？

如果是，则可以使在notify() for循环中使用的iter无效。您可能想将notify()更改为如下所示，将所有shared_ptr对象排队通知，这样listeners集合在任何onNotify()回调过程中是否被修改都无关紧要：

#include <queue>
void notify(std::function<void(std::shared_ptr<T>)> onNotify)
{
    std::queue<std::shared_ptr<T>> notify_targets;
    for (auto iter=listeners.begin(); iter != listeners.end(); ) {
        if (auto shared = iter->lock()) {
            notify_targets.push(shared);
            iter++;
        } else {
            iter = listeners.erase(iter);
        }
    }
    while (!notify_targets.empty()) {
        onNotify(notify_targets.front());
        notify_targets.pop();
    }
}

Answer 2

我在您显示的代码中找不到明显的问题。因此，我认为问题存在于您没有显示的代码中。请记住，Q_OBJECT装饰的物品也有与qt相关的生命周期管理。也许有什么干扰。。。

如果你将你的代码与我在这里发布的代码进行比较，你会很快发现关键的区别，也许这会有所帮助。

#include <vector>
#include <algorithm>
#include <memory>
template <typename _Observable>
class IObserver
{
public:
    virtual ~IObserver() {}
    virtual void OnChange(const _Observable* what) = 0;
};
template <class T>
class CObservable
    : public IObserver<T> // Make sure this class breaks once IObserver<> changes.
{
public:
    typedef IObserver<T> Observer_t;
    typedef std::weak_ptr<Observer_t> Observer_reference;
    typedef std::shared_ptr<Observer_t> Observer_strong_reference;
    typedef T Class_t;
    typedef std::vector<Observer_reference> ObserverRefCollection;
private:
    ObserverRefCollection m_observers;
    void CleanupZombies()
    {
        m_observers.erase(std::remove_if(m_observers.begin(), m_observers.end(),
            [this](Observer_reference iter) -> bool
        {
            Observer_strong_reference o = iter.lock();
            return !o;
        }
        ), m_observers.end());
    }
public:
    void RegisterObserver(Observer_strong_reference& observer)
    {
        if (!observer)
            return;
        for (auto& iter : m_observers)
        {
            if (observer == iter.lock())
                return;
        }
        m_observers.push_back(Observer_reference(observer));
    }
    /*virtual*/ void OnChange(const Class_t* what)
    {
        bool hasZombies = false;
        for (auto& iter : m_observers)
        {
            Observer_strong_reference o = iter.lock();
            if (o)
            {
                o->OnChange(what);
            }
            else
            {
                hasZombies = true;
            }
        }
        if (hasZombies)
            CleanupZombies();
    }
};
class CObservableUint32
    : public CObservable<CObservableUint32>
{
    uint32_t m_value;
public:
    void Set(uint32_t newValue)
    {
        bool changed = newValue != m_value;
        m_value = newValue;
        if (changed)
        {
            OnChange(this);
        }
    }
    uint32_t Get() const
    {
        return m_value;
    }
};
class CSomeObserver
    : public IObserver < CObservableUint32 >
{
public:
    CSomeObserver()
        : IObserver<CObservableUint32>()
    {
    }
    virtual ~CSomeObserver()
    {
    }
    virtual void OnChange(const CObservableUint32* what)
    {
    }
};

在其他地方。。。

    CObservableUint32 observable;
    {
        std::shared_ptr<IObserver<CObservableUint32> > observer = std::make_shared<CSomeObserver>();
        observable.RegisterObserver(observer);
        observable.Set(42UL);
    }
    observable.Set(100);