なぜstd::function平等は比較できないのですか？
主な理由は、もしそうなら、たとえ等価比較が実行されなくても、非等価比較型では使用できなかったからだと思います。
つまり、比較を実行するコードは、早い段階でインスタンス化する必要がありますstd::function。たとえば、コンストラクターまたは代入演算子のいずれかで、呼び出し可能なオブジェクトが に格納された時点です。
このような制限は、アプリケーションの範囲を大幅に狭め、明らかに「汎用ポリモーフィック関数ラッパー」には受け入れられません。
a を呼び出し可能なオブジェクトと比較するboost::functionことは可能であることに注意することが重要です(ただし、別の とは比較できませんboost::function) 。
関数オブジェクト ラッパーは、ラッパー内に格納できる任意の関数オブジェクトを介して==、またはそれに対して比較できます。!=
このような比較を実行する関数は、既知のオペランド型に基づいて比較ポイントでインスタンス化されるため、これが可能です。
さらに、std::function同様の比較を実行するために使用できるtargetテンプレートメンバー関数があります。実際、boost::function比較演算子はメンバー関数の観点から実装されていtargetます。
したがって、 の実装を妨げる技術的な障壁はありませんfunction_comparable。
答えの中には、一般的な「一般的に不可能」なパターンがあります。
それでも、(たとえば) 異なる順序で引数をバインドすることによって構築された場合、同等の関数は等しくないと比較されるため、同等の狭い概念が得られます。一般的なケースで同等性をテストすることは不可能だと思います。
私は間違っているかもしれませんが、std::functionオブジェクトの平等は残念ながら一般的な意味では解決できないと思います。
チューリングマシンの等価性は決定できないからです。2 つの異なる関数オブジェクトが与えられた場合、それらが同じ関数を計算するかどうかを判断できない可能性があります。[その回答は削除されました]
私はこれに完全に同意しませんstd::function。比較自体を実行するのは仕事ではありません。その仕事は、リクエストを基になるオブジェクトとの比較にリダイレクトすることだけです-それだけです。
基になるオブジェクト タイプで比較が定義されていない場合は、コンパイル エラーになります。いずれにせよ、std::function比較アルゴリズムを推測する必要はありません。
基礎となるオブジェクト型が比較を定義しているが、それが正しく動作しないか、異常なセマンティクスを持っている場合、std::functionそれ自体の問題ではなく、基礎となる型の問題です。
function_comparableに基づいて実装することが可能std::functionです。
概念実証は次のとおりです。
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ます。
たとえば、 s のベクトルがありstd::function、ユーザーregister_callbackとunregister_callback関数を提供したいとしましょう。の使用は、パラメータfunction_comparableにのみ必要です:unregister_callback
void register_callback(std::function<function_signature> callback);
void unregister_callback(function_comparable<function_signature> callback);
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)。