qt — C ++ слабый_поселок () segfault
Таким образом, у меня есть эта функция для добавления прослушивателей, и она преобразует общие указатели класса, чтобы я мог вызвать ее позже, когда получу уведомление.
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;
и по какой-то причине segfaults «iter-> lock ()». Я скажу, что это приложение Qt, но я специально не создавал НИКАКИХ потоков (которые я знаю), поэтому я просто запутался в том, что я делаю неправильно, чтобы сломать эти weak_ptrs. Так что, если я запускаю его в 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>) ()
РЕДАКТИРОВАТЬ: Майкл Барр опубликовал возможность регистрации слушателей, в то время как новые слушатели были добавлены, что может произойти. Это может привести к тому, что итератор будет недействительным, и когда я пойду, чтобы вызывать weak_ptr.lock () для раздела памяти, который не является слабым_птром, BOOM. Я думаю, что здесь где-то есть мораль, я просто должен ее найти.
Решение
когда notify() Возможно ли, что функция вызывается через onNotify() функциональный объект приведет к registerListener() вызывается косвенно (или какой-либо другой код, который может добавлять или удалять записи в listeners коллекция)?
Если так, то iter используется в notify() for цикл может быть недействительным. Вы можете изменить 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();
}
}
Другие решения
Я не могу найти очевидную проблему в коде, который вы показываете. Поэтому я предполагаю, что проблема заключается в коде, который вы не показываете. Имейте в виду, что объекты, украшенные 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);