为什么 std::function 不能相等比较？

Question

这个问题也适用于 boost::function 和 std::tr1::function。

std::function 不可进行等式比较：

#include <functional>
void foo() { }

int main() {
    std::function<void()> f(foo), g(foo);
    bool are_equal(f == g); // Error:  f and g are not equality comparable
}

在 C++11 中，operator== 和 operator!= 重载根本不存在。在早期的 C++11 草案中，重载被声明为已删除，并带有注释 (N3092 §20.8.14.2)：

// deleted overloads close possible hole in the type system

它没有说明“类型系统中可能的漏洞”是什么。在 TR1 和 Boost 中，声明了重载但未定义。 TR1 规范注释 (N1836 §3.7.2.6)：

这些成员函数应保持未定义。

[注意：类似布尔的转换打开了一个漏洞，可以通过 == 或 != 比较两个函数实例。这些未定义的 void 运算符封闭了漏洞并确保编译时错误。 —尾注]

我对“漏洞”的理解是，如果我们有一个 bool 转换函数，则该转换可以用于相等比较（以及其他情况下）：

struct S {
    operator bool() { return false; }
};

int main() {
    S a, b;
    bool are_equal(a == b); // Uses operator bool on a and b!  Oh no!
}

我的印象是，C++03 中的 safe-bool 习惯用法和 C++11 中显式转换函数的使用是为了避免这个“漏洞”。 Boost 和 TR1 都在 function 中使用 safe-bool 习惯用法，并且 C++11 使 bool 转换函数显式化。

作为同时具有这两种功能的类的示例，std::shared_ptr 都具有显式 bool 转换函数并且可以进行相等比较。

为什么 std::function 不能进行相等比较？什么是“类型系统中可能的漏洞？”它与 std::shared_ptr 有何不同？

Answer 1

为什么是std::function 不具有可比性吗？

std::function 是任意可调用类型的包装器，因此为了实现相等比较，您必须要求所有可调用类型都是相等比较的，这给任何实现者带来了负担一个函数对象。即使这样，您也会得到一个狭窄的相等概念，因为如果（例如）它们是通过以不同顺序绑定参数来构造的，则等效函数将比较不相等。我相信在一般情况下不可能测试等效性。

“类型系统中可能存在的漏洞是什么？”

我猜这意味着删除运算符并且确定使用它们永远不会给出有效的代码比证明在某些先前未发现的极端情况下不可能发生不需要的隐式转换更容易。

它与std::shared_ptr有什么不同?

std::shared_ptr 具有明确定义的相等语义；两个指针相等当且仅当它们都为空或都非空且指向同一个对象时。

Answer 2

我可能是错的，但我认为 std::function 对象的相等性在一般意义上是不可解决的。例如：

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

void f() {
    printf("hello\n");
}

int main() {
    boost::function<void()> f1 = f;
    boost::function<void()> f2 = boost::bind(f);

    f1();
    f2();
}

f1 和 f2 相等吗？如果我添加任意数量的函数对象，这些函数对象以各种方式简单地相互包装，最终归结为对 f 的调用...仍然相等，该怎么办？

Answer 3

为什么 std::function 不能进行相等比较？

我认为主要原因是，如果是的话，那么它就不能与非相等比较类型一起使用，即使从未执行相等比较。

即执行比较的代码应该尽早实例化 - 当可调用对象存储到 std::function 中时，例如在构造函数或赋值运算符之一中。

这样的限制会大大缩小应用范围，对于“通用多态函数包装器”来说显然是不可接受的。

---

值得注意的是，可以 将 boost::function 与可调用对象进行比较（但不与另一个 boost::function）

函数对象包装器可以通过 == 或 != 与可以存储在包装器中的任何函数对象进行比较。

这是可能的，因为执行此类比较的函数是根据已知的操作数类型在比较点实例化的。

此外，std::function有一个< strong>target模板成员函数，可以用来进行类似的比较。事实上 boost::function 的比较运算符是 根据target成员函数实现。

因此，不存在阻碍 function_comparable 实现的技术障碍。

---

在答案中存在常见的“一般不可能”模式：

• 即使这样，您也会得到一个狭义的相等概念，因为如果（例如）它们是通过以不同顺序绑定参数来构造的，则等效函数将比较不相等。我相信在一般情况下不可能测试等效性。

• <块引用>

  我可能是错的，但不幸的是，我认为 std::function 对象的相等性在一般意义上是不可解决的。

• <块引用>

  因为图灵机的等价性是不可判定的。给定两个不同的函数对象，您不可能确定它们是否计算相同的函数。 [该答案已被删除]

我完全不同意这一点：执行比较本身不是 std::function 的工作；它的工作只是重定向请求以与底层对象进行比较 - 仅此而已。

如果底层对象类型没有定义比较 - 这将是一个编译错误；无论如何，都不需要 std::function 来推导比较算法。

如果底层对象类型定义了比较，但工作错误，或者有一些不寻常的语义 - 这也不是 std::function 本身的问题，而是底层类型的问题。

---

可以基于std::function实现function_comparable。

这是一个概念验证：

template<typename Callback,typename Function> inline
bool func_compare(const Function &lhs,const Function &rhs)
{
    typedef typename conditional
    <
        is_function<Callback>::value,
        typename add_pointer<Callback>::type,
        Callback
    >::type request_type;

    if (const request_type *lhs_internal = lhs.template target<request_type>())
        if (const request_type *rhs_internal = rhs.template target<request_type>())
            return *rhs_internal == *lhs_internal;
    return false;
}

#if USE_VARIADIC_TEMPLATES
    #define FUNC_SIG_TYPES typename ...Args
    #define FUNC_SIG_TYPES_PASS Args...
#else
    #define FUNC_SIG_TYPES typename function_signature
    #define FUNC_SIG_TYPES_PASS function_signature
#endif

template<FUNC_SIG_TYPES>
struct function_comparable: function<FUNC_SIG_TYPES_PASS>
{
    typedef function<FUNC_SIG_TYPES_PASS> Function;
    bool (*type_holder)(const Function &,const Function &);
public:
    function_comparable() {}
    template<typename Func> function_comparable(Func f)
        : Function(f), type_holder(func_compare<Func,Function>)
    {
    }
    template<typename Func> function_comparable &operator=(Func f)
    {
        Function::operator=(f);
        type_holder=func_compare<Func,Function>;
        return *this;
    }
    friend bool operator==(const Function &lhs,const function_comparable &rhs)
    {
        return rhs.type_holder(lhs,rhs);
    }
    friend bool operator==(const function_comparable &lhs,const Function &rhs)
    {
        return rhs==lhs;
    }
    friend void swap(function_comparable &lhs,function_comparable &rhs)// noexcept
    {
        lhs.swap(rhs);
        lhs.type_holder.swap(rhs.type_holder);
    }
};

有一个很好的属性 - function_comparable 可以与 std::function也是。

例如，假设我们有 std::functions 向量，并且我们希望为用户提供 register_callback 和 unregister_callback 函数。仅 unregister_callback 参数需要使用 function_comparable：

void register_callback(std::function<function_signature> callback);
void unregister_callback(function_comparable<function_signature> callback);

现场演示 < strong>Ideone

演示源代码：

//             Copyright Evgeny Panasyuk 2012.
// Distributed under the Boost Software License, Version 1.0.
//    (See accompanying file LICENSE_1_0.txt or copy at
//          http://www.boost.org/LICENSE_1_0.txt)

#include <type_traits>
#include <functional>
#include <algorithm>
#include <stdexcept>
#include <iostream>
#include <typeinfo>
#include <utility>
#include <ostream>
#include <vector>
#include <string>

using namespace std;

// _____________________________Implementation__________________________________________

#define USE_VARIADIC_TEMPLATES 0

template<typename Callback,typename Function> inline
bool func_compare(const Function &lhs,const Function &rhs)
{
    typedef typename conditional
    <
        is_function<Callback>::value,
        typename add_pointer<Callback>::type,
        Callback
    >::type request_type;

    if (const request_type *lhs_internal = lhs.template target<request_type>())
        if (const request_type *rhs_internal = rhs.template target<request_type>())
            return *rhs_internal == *lhs_internal;
    return false;
}

#if USE_VARIADIC_TEMPLATES
    #define FUNC_SIG_TYPES typename ...Args
    #define FUNC_SIG_TYPES_PASS Args...
#else
    #define FUNC_SIG_TYPES typename function_signature
    #define FUNC_SIG_TYPES_PASS function_signature
#endif

template<FUNC_SIG_TYPES>
struct function_comparable: function<FUNC_SIG_TYPES_PASS>
{
    typedef function<FUNC_SIG_TYPES_PASS> Function;
    bool (*type_holder)(const Function &,const Function &);
public:
    function_comparable() {}
    template<typename Func> function_comparable(Func f)
        : Function(f), type_holder(func_compare<Func,Function>)
    {
    }
    template<typename Func> function_comparable &operator=(Func f)
    {
        Function::operator=(f);
        type_holder=func_compare<Func,Function>;
        return *this;
    }
    friend bool operator==(const Function &lhs,const function_comparable &rhs)
    {
        return rhs.type_holder(lhs,rhs);
    }
    friend bool operator==(const function_comparable &lhs,const Function &rhs)
    {
        return rhs==lhs;
    }
    // ...
    friend void swap(function_comparable &lhs,function_comparable &rhs)// noexcept
    {
        lhs.swap(rhs);
        lhs.type_holder.swap(rhs.type_holder);
    }
};

// ________________________________Example______________________________________________

typedef void (function_signature)();

void func1()
{
    cout << "func1" << endl;
}

void func3()
{
    cout << "func3" << endl;
}

class func2
{
    int data;
public:
    explicit func2(int n) : data(n) {}
    friend bool operator==(const func2 &lhs,const func2 &rhs)
    {
        return lhs.data==rhs.data;
    }
    void operator()()
    {
        cout << "func2, data=" << data << endl;
    }
};
struct Caller
{
    template<typename Func>
    void operator()(Func f)
    {
        f();
    }
};
class Callbacks
{
    vector<function<function_signature>> v;
public:
    void register_callback_comparator(function_comparable<function_signature> callback)
    {
        v.push_back(callback);
    }
    void register_callback(function<function_signature> callback)
    {
        v.push_back(callback);
    }
    void unregister_callback(function_comparable<function_signature> callback)
    {
        auto it=find(v.begin(),v.end(),callback);
        if(it!=v.end())
            v.erase(it);
        else
            throw runtime_error("not found");
    }
    void call_all()
    {
        for_each(v.begin(),v.end(),Caller());
        cout << string(16,'_') << endl;
    }
};

int main()
{
    Callbacks cb;
    function_comparable<function_signature> f;
    f=func1;
    cb.register_callback_comparator(f);

    cb.register_callback(func2(1));
    cb.register_callback(func2(2));
    cb.register_callback(func3);
    cb.call_all();

    cb.unregister_callback(func2(2));
    cb.call_all();
    cb.unregister_callback(func1);
    cb.call_all();
}

输出为：

func1
func2, data=1
func2, data=2
func3
________________
func1
func2, data=1
func3
________________
func2, data=1
func3
________________

PS 似乎在 std::type_index，可以实现类似于function_comparable类的东西，它也支持排序（即std ::less）甚至是散列。不仅可以在不同类型之间排序，还可以在同一类型内排序（这需要类型的支持，例如 LessThanComparable）。

Answer 4

根据 http://www.open- std.org/jtc1/sc22/wg21/docs/lwg-active.html#1240：

这里的主要评论是
std::function 的历史，其中
与 N1402 一起推出。在那期间
时间没有显式转换函数
存在，并且“safe-bool”习语
（基于指向成员的指针）是
流行技术。唯一的
这个习语的缺点是
给定两个类型为 f1 和 f2 的对象
std::function，表达式

f1 == f2;

格式良好，只是因为
内置 operator== 用于指针
会员在一次后被考虑
用户定义的转换。为了解决这个问题，
未定义的重载集
添加了比较功能，例如
重载决议更喜欢
那些最终导致链接错误的。
删除的新语言设施
功能提供了更好的
修复此问题的诊断机制
问题。

在 C++11 中，删除的函数被认为是多余的，因为引入了显式转换运算符，因此它们可能会在 C++11 中删除。

这个问题的中心点是，
与更换
通过显式转换实现 safe-bool 习惯用法
到 bool，原始的“类型中的漏洞”
系统”已不存在并且
因此该评论是错误的
多余的函数定义
也应该被删除。

至于为什么不能比较 std::function 对象，可能是因为它们可能保存全局​​/静态函数、成员函数、仿函数等，并且要执行此操作 std::函数“擦除”有关底层类型的一些信息。因此，实现相等运算符可能是不可行的。

Answer 5

其实，你可以比较目标。它可能有效取决于您想要从比较中得到什么。

这里的代码带有不等式，但您可以看到它是如何工作的：

template <class Function>
struct Comparator
{
    bool operator()(const Function& f1, const Function& f2) const
    {
        auto ptr1 = f1.target<Function>();
        auto ptr2 = f2.target<Function>();
        return ptr1 < ptr2;
    }
};

typedef function<void(void)> Function;

set<Function, Comparator<Function>> setOfFunc;

void f11() {}

int _tmain(int argc, _TCHAR* argv[])
{
    cout << "was inserted - " << setOfFunc.insert(bind(&f11)).second << endl;  // 1 - inserted
    cout << "was inserted - " << setOfFunc.insert(f11).second << endl;         // 0 - not inserted
    cout << "# of deleted is " << setOfFunc.erase(f11) << endl;

    return 0;
}

Ups，它仅从 C++11 起有效。

Answer 6

尝试下面的方法怎么样，这对于测试模板很有效。

if (std::is_same<T1, T2>::value)
{
    ...
}

Answer 7

至少可以做的是，如果 std::function 保存用于绑定到字符串的函数的地址并改为使用字符串比较。