Pourquoi est std::function et non l'égalité comparable?

Pourquoi est std::function pas l'égalité comparable?

std::function est un wrapper pour arbitraire appelable types, afin de mettre en œuvre l'égalité de comparaison à tous, vous auriez à exiger que tous les appelable types de l'égalité-comparible, placer un fardeau sur quelqu'mise en œuvre d'une fonction d'objet. Même alors, vous obtiendrez un concept étroit de l'égalité, comme l'équivalent des fonctions serait de comparer l'inégalité (par exemple) si elles ont été construites par la liaison des arguments dans un ordre différent. Je crois qu'il est impossible de tester l'équivalence dans le cas général.

Qu'est-ce que la possibilité "d'un trou dans le type de système?"

Je suppose que cela signifie qu'il est plus facile de supprimer les opérateurs, et soyez certains que leur utilisation ne donnera jamais le code est valide, que pour prouver il n'y a pas de possibilité indésirables des conversions implicites dans certains jusque-là inconnues des cas de coin.

Comment est-il différent de std::shared_ptr?

std::shared_ptr a bien défini l'égalité sémantique; deux pointeurs sont égaux si et seulement si ils sont tous les deux vides, ou les deux non-vide et pointant vers le même objet.

Pourquoi est std::function pas l'égalité comparable?

Je pense que la raison principale est que si elle l'était, il ne pouvait pas être utilisés avec de non égalité de types comparables, même si la comparaison d'égalité n'est jamais effectuée.

I. e. le code qui effectue la comparaison doit être instancié précoce, au moment où un objet appelable est stocké dans std::function, par exemple dans l'un des constructeurs ou des opérateurs d'affectation.

Une telle limitation serait grandement réduire la portée de l'application, et, évidemment, de ne pas être acceptable pour un "à des fins générales fonction polymorphe wrapper".

---

Il est important de noter qu'il est possible de comparer un boost::function avec un objet appelable (mais pas avec un autre boost::function)

Fonction de l'objet wrappers peuvent être comparés par == ou != à l'encontre de toute la fonction de l'objet qui peut être stocké à l'intérieur de l'emballage.

C'est possible, parce que la fonction qui effectue une telle comparaison est instancié à un point de comparaison, sur la base des types d'opérande.

En outre, std::function a un cible modèle de fonction de membre, qui peut être utilisé pour effectuer la comparaison similaire. En fait boost::function's les opérateurs de comparaison sont mis en œuvre en termes de cible de la fonction membre.

Donc, il n'y a pas d'obstacles techniques qui bloquent la mise en œuvre de function_comparable.

---

Parmi les réponses, il est commun "impossible en général" modèle:

• Même alors, vous obtiendrez un concept étroit de l'égalité, comme l'équivalent des fonctions serait de comparer l'inégalité (par exemple) si elles ont été construites par la liaison des arguments dans un ordre différent. Je crois qu'il est impossible de tester l'équivalence dans le cas général.

• J'ai peut-être tort, mais je pense que l'égalité est de std::function objets est, malheureusement, n'est pas soluble dans le sens générique.

• Parce que l'équivalence des machines de Turing est indécidable. Étant donné deux fonctions différentes des objets, vous ne pouvez pas éventuellement de déterminer si ils calculent la même fonction ou pas. [Cette réponse a été supprimée]

Je suis complètement en désaccord avec ceci: il n'est pas le travail de std::function pour effectuer la comparaison elle-même; son travail est juste pour rediriger demande à la comparaison d'objets sous-jacents, c'est tout.

Si le sous-jacent type d'objet ne définit pas de la comparaison, il aura une erreur de compilation; en tout cas, std::function n'est pas nécessaire d'en déduire un algorithme de comparaison.

Si le sous-jacent type d'objet définit la comparaison, mais qui fonctionne à tort, ou a quelques-uns inhabituelle sémantique, il n'est pas le problème de std::function elle-même, mais c'est le problème de la type sous-jacent.

---

Il est possible de mettre en œuvre function_comparable basé sur std::function.

Ici est une preuve-de-concept:

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);
}
};

Il y a une belle propriété - function_comparable peut être comparé à des std::function trop.

Par exemple, disons que nous avons vecteur de std::functions, et nous voulons donner aux utilisateurs register_callback et unregister_callback fonctions. L'utilisation de function_comparable est requise uniquement pour les unregister_callback paramètre:

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

Démonstration en direct à Ideone

Le code Source de la démo:

//            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();
}

De sortie est:

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

P. S. Il semble que, avec l'aide de std::type_index, il est possible de mettre en place quelque chose de similaire à function_comparable classe, qui prend également en charge la commande (c'est à dire std::less) ou même de hachage. Non seulement la commande entre les différents types, mais aussi de la commande au sein d'un même type (ce qui nécessite la prise en charge de types, comme LessThanComparable).

En fait, vous pouvez comparer les cibles. Il peut travailler dépend de ce que vous voulez de comparaison.

Ici le code de l'inégalité, mais vous pouvez voir comment cela fonctionne:

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, il n'est valable que depuis C++11.

le moins qui puisse être fait est si std::fonction enregistre l'adresse de la fonction utilisée pour la liaison à une chaîne et utilisé comparaison de chaînes de caractères à la place.