使用时删除升压功能

Question

我遇到的情况是 boost::function 和 boost::bind （实际上是 std::tr1::function 和 bind）在使用时被删除。 这安全吗？ 我通常会避免它，但有问题的代码有点根深蒂固，我唯一的其他选择是添加一个新线程。

typedef function<int(int)> foo_type;

foo_type* global_foo = NULL;

int actual_foo( int i, Magic* m )
{
    delete global_foo;
    return m->magic(i);
}

int main()
{
     Magic m;
    global_foo = new foo_type( bind( &actual_foo, _1, &m );

    return (*global_foo)(10)
}

绑定参数始终是普通整型（实际代码中的 int 和指针），而不是引用。

Answer 1

boost::function 或 std::tr1::functions 是可复制对象。 因此，通常绝对没有理由分配它们——只需按值传递它们即可。

它们针对大​​多数实际情况进行了很好的优化...所以只需按值传递它们：

typedef function<int(int)> foo_type;

foo_type global_foo;

int actual_foo( int i, Magic* m )
{
   delete global_foo;
   return m->magic(i);
}

int main()
{
   Magic m;
   global_foo = bind( &actual_foo, _1, &m );

   return global_foo(10)
}

您建议的代码是危险的，运行此代码：

    #include <boost/function.hpp>
    #include <boost/bind.hpp>
    #include <iostream>
    using namespace std;

    boost::function<void()> *glb;

    struct Data {
            int x;
            Data(int _x = 0) : x(_x) { cout<<"ctor:"<<this<<endl; }
            ~Data() { cout<<"dtor:"<<this<<endl; }
            Data(Data const &p) {x=p.x; cout<<"ctor:"<<this<<endl; }
            Data const &operator=(Data const &p) { x=p.x; cout<<this<<"="<<&p<<endl; return *this; }
    };

    void func(Data const &x)
    {
            delete glb;
            cout<<&x<<endl;
    }

    int main()
    {
            glb=new boost::function<void()>(boost::bind(func,Data(3)));

            (*glb)();
            return 0;
    }

您会发现您尝试在 func 中访问已销毁的对象cout<<&x< 中显示的（具有相同指针值的 dtor）已被调用。

因为当你销毁函数对象时，你也销毁了绑定的参数
have 和 Data const &x 变得不可用，因为它已被 global_function 破坏

编辑： 注释说明：

如果您有类似的内容

map<string,function<void()> > calls;

void delete_key(){
    calls.erase("key");
}

main() 
{
     calls["key"]=delete_key;

     // Wrong and dangerous
     // You delete function while in use
     calls["key"]();

     // Correct and safe
     // You create a copy of function so it would not
     // be deleted while in use.
     function<void()> f=calls["key"];
     f();
}

Answer 2

编辑：（与 Charles Bailey）进一步讨论了这个答案，我认为这是不安全的，因为它取决于 boost::function 的实现。

当我们进入actual_foo时，调用堆栈将如下所示：

actual_foo
boost::function::operator()
main

因此，当actual_foo执行完成时，我们将跳回到boost::function的operator()代码，并且该对象已被删除。 这并不保证会成为问题 - 这有点像调用 delete this - 但您必须非常小心在已删除对象的成员函数中执行的操作。 您不得调用任何虚拟函数或使用任何数据成员。

问题是我不知道 boost::function 在调用它所包装的函数之后对它在 operator() 中执行的操作做出任何保证。 在我的平台上，它似乎没有做任何危险的事情（所以 valgrind 不会抱怨），但完全可以想象，在不同的平台上，使用不同的实现，或者使用不同的编译标志，它可能想做一些不一旦对象被删除就不允许 - 例如它可能使用成员变量写出一些调试信息。

因此，我认为这是一件危险的事情，在某些情况下可能会导致未定义的行为。

进一步说明：

我快速浏览了一下 boost 在调用函数指针后到底做了什么。 看这里： http://boost .cvs.sourceforge.net/viewvc/boost/boost/boost/function/function_template.hpp?view=markup 在第687行的operator()函数处，我的解释是它立即返回返回值并且不不做任何其他事情，所以在实践中，通过这种实现，你应该没问题，但关于它是危险的评论仍然存在。 请注意，我很可能发现了错误的代码和/或理解错误......

下面的原始答案：

我相信这是可以的。 当您输入 actual_foo 时，boost::bind 和 boost::function 对象已经完成了它们的工作，并且您正在执行真正的函数actual_foo。

我通过 valgrind 运行程序，在我的平台（gcc 4.2.4、Linux）上检查了这一点。

这是我运行的程序：

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

class Magic
{
public:
    int magic( int i )
    {
        return 5;
    }
};

typedef boost::function<int(int)> foo_type;

foo_type* global_foo = NULL;

int actual_foo( int i, Magic* m )
{
    delete global_foo;
    return m->magic(i);
}

int main()
{
    Magic m;
    global_foo = new foo_type( boost::bind( &actual_foo, _1, &m ) );

    return (*global_foo)(10);
}

这是 valgrind 的输出：

$ valgrind ./boost_bind
==17606== Memcheck, a memory error detector.
==17606== Copyright (C) 2002-2007, and GNU GPL'd, by Julian Seward et al.
==17606== Using LibVEX rev 1804, a library for dynamic binary translation.
==17606== Copyright (C) 2004-2007, and GNU GPL'd, by OpenWorks LLP.
==17606== Using valgrind-3.3.0-Debian, a dynamic binary instrumentation framework.
==17606== Copyright (C) 2000-2007, and GNU GPL'd, by Julian Seward et al.
==17606== For more details, rerun with: -v
==17606== 
==17606== 
==17606== ERROR SUMMARY: 0 errors from 0 contexts (suppressed: 17 from 1)
==17606== malloc/free: in use at exit: 0 bytes in 0 blocks.
==17606== malloc/free: 1 allocs, 1 frees, 16 bytes allocated.
==17606== For counts of detected errors, rerun with: -v
==17606== All heap blocks were freed -- no leaks are possible.

不过，我必须说，这似乎是一件奇怪的事情。 如果可能的话，我更愿意通过将其设为堆栈变量来自动删除此函数对象，或者在堆栈变量的析构函数中删除它（如 RAII）。 它会更整洁、更安全、不那么可怕，而且更安全。 但我确信您已经了解了所有这些，并且有充分的理由按原样使用代码。