Альтернатива для обратных вызовов с использованием std::function

Основная проблема заключается в том, что большинство функциональных объектов несопоставимы. В то время как простые указатели функций и пользовательские объекты функций с оператором равенства можно сравнивать, лямбда-выражения, результат std::bind() и т. д. не могут. Использование адреса функциональных объектов для их идентификации, как правило, не является подходящим подходом, поскольку объекты имеют тенденцию к копированию. Возможно можно использовать std::reference_wrapper<Fun>, чтобы избежать их копирования, но объекты, хранящиеся в std::function<F>, по-прежнему будут иметь другой адрес.

С вариативными шаблонами C++11 достаточно легко создать пользовательскую версию std::function<...>, которая предоставляет средства сравнения. Их может быть даже две версии:

• Одна версия, которая принимает произвольные функциональные объекты, но, очевидно, может сравнивать только сравнимые функциональные объекты: в зависимости от того, предоставляет ли аргумент конструктора оператор равенства или нет, используется подходящий базовый класс.
• Одна версия, которая всегда обеспечивает рабочее сравнение и, очевидно, не может использоваться с объектами, не сравнимыми по равенству.

Последнее определить немного проще, и оно будет выглядеть примерно так:

template <typename...> class comparable_function;
template <typename RC, typename... Args>
class comparable_function<RC(Args...)> {
    struct base {
        virtual ~base() {}
        virtual RC    call(Args... args) = 0;
        virtual base* clone() const = 0;
        virtual bool  compare(base const*) const = 0;
    };
    template <typename Fun>
    struct concrete: base {
        Fun fun;
        concrete(Fun const& fun): fun(fun) {}
        RC call(Args... args) { return this->fun(args...); }
        base* clone() const { return new concrete<Fun>(this->fun); }
        bool compare(base const* other) const {
             concrete const* o = dynamic_cast<concrete<Fun>>(other);
             return o && this->fun == o->fun;
        }
    };
    std::unique_ptr<base> fun;
public:
    template <typename Fun>
    comparable_function(Fun fun): fun(new concrete<Fun>(fun)) {}
    comparable_function(comparable_function const& other): fun(other.fun->clone()) {}
    RC operator()(Args... args) { return this->fun->call(args); }
    bool operator== (comparable_function const& other) const {
        return this->fun->compare(other.fun.get());
    }
    bool operator!= (comparable_function const& other) { return !(this == other); }
};

Наверное, я что-то забыл (и/или опечатался), но это то, что нужно. Для необязательно сопоставимой версии у вас будет две версии concrete: одна, которая реализована, как указано выше, и другая, которая всегда возвращает false. В зависимости от того, есть ли в конструкторе оператор == для Fun, вы должны создать тот или иной.

Ну, а что, если вы сделаете что-то вроде:

class C2
{
public:
   void registerCallback(function<void(int)>* f)
   {
      v.push_back(f);
   }

private:
   vector<function<void(int)>*> v;

   void callThem()
   {
      for (int i=0; i<v.size(); i++)
      {
         v[i][0](i);
      }
   }
};

Функции несопоставимы, но указатели сравнимы. Причина, по которой функции несопоставимы, заключается в том, что нет способа определить, равны ли функции (не только в C++, в информатике). То есть невозможно определить, имеют ли функции одинаковое значение. Однако, используя указатели, мы можем, по крайней мере, увидеть, занимают ли они одно и то же место в памяти.

Я не очень хорошо знаком с тем, как bind и другие стандартные функции более высокого порядка работают под капотом. Будьте осторожны при использовании этого, и вам, возможно, придется выполнять свои собственные проверки при регистрации обратного вызова или перед вызовом привязки, чтобы убедиться, что у вас нет двух дублирующих привязок одной и той же функции, но которые занимают разные места в памяти.

Я думаю, что есть фундаментальная проблема с автоматическим обнаружением двойной регистрации. Когда вы считаете две функции идентичными? Для обычных указателей на функции вы можете использовать адрес, но с std::bind и особенно с лямбда-функциями у вас возникнут проблемы:

class C2
{
public:
   void registerCallback(??? f)
   {
      if (v.find(f, ???) == v.end())
          v.push_back(f);
   }
private:
   vector<function<void(int)>> v;
};

void f1(int);
void f3(int, int);
void f2(int)
{
   C2 c;
   c.registerCallback(f1);
   c.registerCallback(f1); // could be detected by address
   c.registerCallback([](int x) {});
   c.registerCallback([](int x) {}); // detected ?!? 
   c.registerCallback(std::bind(f3, _1, 1);
   c.registerCallback([](int x) {f3(x,1);}) ; // detected? 
}

Компилятор не может определить, что две лямбда-функции семантически идентичны.

Я бы изменил register, чтобы он возвращал идентификатор (или объект подключения, как в Boost.Signal2), который может использоваться клиентами для отмены регистрации обратных вызовов. Однако это не предотвратит двойную регистрацию.

class C2
{
public:
   typedef ??? ID;
   ID registerCallback(??? f)
   {
      ?? id = new_id();
      v[id] = f;
   }
private:
   map<???, function<void(int)>> v;
};