Question

当我尝试将多个信号连接到单个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个部分清理，但泄漏了一些内存。

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

谢谢，克里斯

Answer 1

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

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行分配的一个对象（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 bug跟踪器，但它已经存在了。然而，这是一个小得多的测试用例。

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

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

Answer 2

对于其他人的参考，我很幸运地保留了我自己的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));
   }
   /* ... */
};

单个slot_type上使用多个boost :: connect的内存泄漏

2 个答案: