1

我有一个 boost::function 对象的列表，并且正在尝试找到一个特定的对象，以便可以将其从列表中删除。实际上注册了一个函数（推送到一个向量上），我希望能够取消注册它（搜索向量并删除匹配的函数指针）。这是代码：

#include <string>
#include <vector>

#include <boost/bind.hpp>
#include <boost/function.hpp>
#include <boost/shared_ptr.hpp>

class DummyClass
{
public:
    std::string Data;
};
typedef boost::shared_ptr<DummyClass> DummyClassPtrType;

class UpdaterClass
{
public:
    void handle(DummyClassPtrType Dummy);
};

class ManagerClass
{
public:
    typedef boost::function<void (DummyClassPtrType Dummy)> HandlerFunctionType;
    typedef std::vector<HandlerFunctionType> HandlerFunctionListType;
    //
    HandlerFunctionListType HandlerFunctionList;
    void registerHandler(HandlerFunctionType Handler)
    {
        HandlerFunctionList.push_back(Handler);
    }
    void unRegister(HandlerFunctionType Handler)
    {
        // find the function pointer in the list and delete it from the list if found
        HandlerFunctionListType::iterator HandlerIter = HandlerFunctionList.begin();
        while (HandlerIter != HandlerFunctionList.end())
        {
            if (*HandlerIter == Handler) // error C2666: 'boost::operator ==' : 4 overloads have similar conversions
            {
                HandlerIter = HandlerFunctionList.erase(HandlerIter);
                break;
            }
            else
            {
                ++HandlerIter;
            }
        }
    }
};

int main()
{
    ManagerClass Manager;
    UpdaterClass Updater;
    Manager.registerHandler(boost::bind(&UpdaterClass::handle, &Updater, _1));
    Manager.unRegister(boost::bind(&UpdaterClass::handle, &Updater, _1));
    return 0;
}

编译器（VS2008 SP1）不喜欢这行：

if (*HandlerIter == Handler)

我不知道如何实现这一目标。

4

2 回答 2

2

除了 Yakk 的回答之外，实现这一点的另一种常用方法是为容器中的项目保留一个迭代器（这个迭代器作用于 Yakk 谈到的“令牌”）。

由于您可能会在删除特定项目之前删除和添加其他项目，因此您必须选择一个不会在插入/删除时使其迭代器无效的容器。std::vector显然不适合这个，但是std::list。

您的registerHandler函数只需要返回由返回的迭代器std::list::insert，并且unregisterHandler只需调用HandlerFunctionList.erase(iteratorToken);.

此实现的唯一缺点是，与 Yakk 不同，它不使用字典来存储令牌，因此它无法事先检查令牌的有效性，如果用户将无效的迭代器传递给您的unregisterHandler.

然而，好处是提高了性能，因为它完全避免了中间字典。

选择你的毒药。

于 2013-05-23T15:50:20.170 回答
1

注册回调时，构建令牌（我通常使用 guid 或int）并将它们返回给调用者。

想要删除回调的调用者必须使用该令牌来发出请求。

这使得可以两次注册相同的函数指针，具有不同的身份，等等。

如果您使用 64 位整数并且只是盲目地递增每个令牌，并且您每帧注册 100 万个函数，并且您以每秒 1000 帧的速度运行，并且您的代码运行了 10 万年，则不会发生回绕。100万年后，它会。决定是否使用完整的指南，或者int您搜索差距并回收它们，是否值得。

另一种选择是使用 astd::unique_ptr<char>( new char() )来滥用堆，并使您的令牌 a void*。

于 2013-05-23T15:43:15.020 回答