2

当我boost::signals尝试将多个信号连接到单个slot_type. 我已经在各种论坛上看到过同样的泄漏报告，但找不到任何提及正确方法或任何解决方法的信息。

我正在尝试做的事情：

我正在尝试将结果传递boost::bind()给函数。在此功能中，我想将多个信号连接到该结果。第一个连接工作正常，但第一个连接之后的每个连接都会泄漏一个句柄。

这是一些示例代码：

typedef boost::signal0<void> LeakSignalType;

class CalledClass
{
   /* ... */
   void connectToSlots(LeakSignalType::slot_type &aSlot)
   {
        LeakSignalType *sig;
        std::list<LeakSignalType*> sigList;
        std::list<LeakSignalType*>::iterator sigIter;

        for(int i = 0; i < 50; i++)
        {
            /*Connect signals to the passed slot */
            sig = new LeakSignalType;
            sig->connect(aSlot);
            sigList.push_back(sig);
        }
        for(sigIter = sigList.begin(); sigIter != sigList.end(); sigIter++)
        {
            /* Undo everything we just did */
            delete *sigIter;
        }
        sigList.clear();
        /*Everything should be cleaned up now */
   }
   /* ... */
}

class CallingClass : public boost::signals::trackable
{
   CalledClass calledInstance;
   /* ... */
   void boundFunction(int i)
   {
   /*Do Something*/
   }

   void connectSignals()
   {
       calledInstance.connectToSlots(boost::bind( &CallingClass::boundFunction, this, 1));
   }
   /* ... */
};

现在打电话CallingClass::connectSignals()。

我希望调用connectToSlots将 50 个信号连接到一个插槽，然后断开并清理所有这些信号。实际发生的是 1 个信号完全清除，然后其余 49 个信号部分清除，但泄漏了一些内存。

将插槽传递给函数以多次使用的正确方法是什么？任何帮助，将不胜感激。

谢谢，克里斯

4

2 回答 2

2

我很确定这是一个错误。如果你把它折叠成一个小例子，例如：

void boundFunction(int) { }
typedef boost::signal0<void> LeakSignalType;
LeakSignalType::slot_type aSlot = boost::bind(&::boundFunction, 1);
LeakSignalType sig1, sig2;
sig1.connect(aSlot);
sig2.connect(aSlot);

并跟踪分配，您会发现boost::signals::detail::signal_base_impl::iterator在第 75 行分配的一个对象 (a )boost/lib/signals/src/signal_base.cpp没有被释放。

// Allocate storage for an iterator that will hold the point of
// insertion of the slot into the list. This is used to later remove
// the slot when it is disconnected.
std::auto_ptr<iterator> saved_iter(new iterator);

在第一个connect，这个迭代器被附加到一个新的连接对象，其中signal_data为 NULL：

data->watch_bound_objects.get_connection()->signal_data =
  saved_iter.release();

然而，在第二个connect中，相同的连接对象被重用，并且同一行盲目地覆盖了原始指针值。第二个对象被清理了，但第一个没有。

作为验证， 中的断点signal_base_impl::slot_disconnected，唯一signal_data被清理的地方，只被触发一次。

我在 1.39.0 中追踪到了这一点，但在 1.40.0 中看起来是一样的。

如果您愿意进行此类更改并运行 Boost 的自定义构建，则可以修改boost::signals::detail::signal_base_impl::connect_slot以清除它在现有连接字段中找到的任何先前的迭代器值。signal_data

最好只是确保您只设置了固定次数并忍受一些您知道不会随着时间而增长的小内存泄漏。

更新：

我打算将此提交给 Boost 错误跟踪器，但它已经在那里了。然而，这是一个小得多的测试用例。

https://svn.boost.org/trac/boost/ticket/738

3 年前开业，未分配到任何里程碑 :-[

于 2009-11-18T02:36:24.437 回答
0

对于其他人的参考，我很幸运地维护了自己的 副本signal_data，并在删除信号之前将其删除。不知道有什么副作用，YMMV。

像这样的东西：

typedef boost::signal0<void> LeakSignalType;
struct LeakSignalStruct
{
    LeakSignalType  signal;
    /* A pointer to keep track of the pointer Boost loses */
    boost::signals::detail::named_slot_map_iterator *signal_data;
};

class CalledClass
{
   /* ... */
   void connectToSlots(LeakSignalType::slot_type &aSlot)
   {
        LeakSignalStruct *sig;
        std::list<LeakSignalStruct*> sigList;
        std::list<LeakSignalStruct*>::iterator sigIter;

        for(int i = 0; i < 50; i++)
        {
            /*Connect signals to the passed slot */
            sig = new LeakSignalStruct;
            sig->connect(aSlot);
            /* Make a backup of the reference that Boost will lose */
            sig->signal_data = (boost::signals::detail::named_slot_map_iterator*)connection.get_connection()->signal_data;
            sigList.push_back(sig);
        }

        /* Boost remembers the last signal_data and will delete it itself,
           so we better lose our reference to avoid double-delete */
        sig->signal_data = NULL;

        for(sigIter = sigList.begin(); sigIter != sigList.end(); sigIter++)
        {
            /* Undo everything we just did */
            /* Boost lost this reference, so we delete it ourselves */
            delete (*sigIter)->signal_data;
            delete *sigIter;
        }
        sigList.clear();
        /*Everything should be cleaned up now */
   }
   /* ... */
};

class CallingClass : public boost::signals::trackable
{
   CalledClass calledInstance;
   /* ... */
   void boundFunction(int i)
   {
   /*Do Something*/
   }

   void connectSignals()
   {
       calledInstance.connectToSlots(boost::bind( &CallingClass::boundFunction, this, 1));
   }
   /* ... */
};
于 2009-11-18T18:13:21.227 回答