Почему std :: function не сравнимо по равенству?
Я думаю, что основная причина в том, что если это так, то его нельзя использовать с сопоставимыми по неравенству типами, даже если сравнение по равенству никогда не выполняется.
т.е. код, который выполняет сравнение, должен быть создан раньше - в тот момент, когда вызываемый объект сохраняется в std :: function, например, в одном из конструкторов или операторов присваивания.
Такое ограничение значительно сузило бы область применения и, очевидно, неприемлемо для "обертки полиморфной функции общего назначения" .
Неверно отметить, что можно сравнить boost :: function с вызываемым объектом (но не с другим boost :: function)
Обертки объекта функции можно сравнить через == или! = С любым объектом функции, который может быть сохранен в оболочке.
Это возможно, потому что функция, которая выполняет такое сравнение, мгновенно вызывается в точке сравнения на основе известного типа операнда.
Кроме того, std :: function имеет target шаблонную функцию , которая может использоваться для аналогичного сравнения. Фактически операторы сравнения boost :: function реализованы в терминах target функция-члена .
Итак, нет технических барьеров, которые блокируют реализацию function_comparable .
Среди ответов распространен шаблон "невозможно вообще":
Даже тогда вы получили бы узкое понятие равенства, поскольку эквивалентные функции сравнивали бы неравно, если бы (например) они были построены путем связывания аргументов в другом порядке. Я считаю, что невозможно проверить на эквивалентность в общем случае.
Возможно, я ошибаюсь, но я думаю, что равенство объектов std :: function, к сожалению, не решаемо в общем смысле.
Потому что эквивалентность машин Тьюринга неразрешима. Учитывая два различных функциональных объекта, вы не можете определить, вычисляют ли они одну и ту же функцию или нет. [Этот ответ был удален]
Я полностью не согласен с этим: задача 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 .
Например, допустим, у нас есть вектор функций 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
________________
P.S. Кажется, что с помощью std :: type_index можно реализовать аналогичный function_comparable класс, который также поддерживает упорядочение (т.е. меньше) или даже хеширование. Но не только упорядочение между разными типами, но и упорядочение внутри одного и того же типа (для этого требуется поддержка типов, таких как LessThanComparable).