Сравнение станд.:: tr1:: функция <> объекты

Я не знаю, заблокированы ли Вы в станд. C++ и tr1, но если Вы не, кажется, что Вашей проблемы можно было бы полностью избежать, если Вы просто использовали что-то как повышение:: сигнал и повышение:: свяжите для решения исходной проблемы - создания системы событий - вместо того, чтобы пробовать к самокрутке.

Предложение (раздел IIIb.) указывает, что они не будут сопоставимы всегда. При присоединении некоторой дополнительной информации к ним можно легко определить каждый обратный вызов. Например, при простом определении структуры, переносящей указатель функции можно удалить их (предположение, что у Вас есть та же структура, которую Вы вставили). Можно также добавить некоторые поля к структуре (как автоматически сгенерированный гуид, за который клиент может держаться), и сравните с этим.

Хорошо, Вы получили меня работа. Твердая часть пытается соответствовать точному шаблону использования событий C#. При пропуске этого существуют НАМНОГО более легкие способы сделать то, что Вы спрашиваете. (Мой коллега Jason использует объект Notifier повсеместно.) Так или иначе вот невероятно скучный код, который делает то, что Вы хотите. К сожалению, это не позволяет Вам передавать параметры от Согласно The Observer. Чтобы сделать это, необходимо было бы добавить еще больше ума.

#include "stdafx.h"
#include <iostream>
#include <string>
#include <list>
#include <algorithm>
#include <boost/tr1/functional.hpp>
#include <boost/tr1/memory.hpp>

using namespace std;
using namespace std::tr1;

template <typename T>
class ObserverHandle
{
public:
    typedef boost::function<void (T*)> const UnderlyingFunction;

    ObserverHandle(UnderlyingFunction underlying)
        : _underlying(new UnderlyingFunction(underlying))
    {
    }

    void operator()(T* data) const
    {
        (*_underlying)(data);
    }

    bool operator==(ObserverHandle<T> const& other) const
    {
        return (other._underlying == _underlying);
    }

private:
    shared_ptr<UnderlyingFunction> const _underlying;
};

class BaseDelegate
{
public:
    virtual bool operator==(BaseDelegate const& other)
    {
        return false;
    }

    virtual void operator() () const = 0;
};

template <typename T>
class Delegate : public BaseDelegate
{
public:
    Delegate(T* observer, ObserverHandle<T> handle)
        : _observer(observer),
        _handle(handle)
    {
    }

    virtual bool operator==(BaseDelegate const& other)
    {
        BaseDelegate const * otherPtr = &other;
        Delegate<T> const * otherDT = dynamic_cast<Delegate<T> const *>(otherPtr);
        return ((otherDT) &&
            (otherDT->_observer == _observer) &&
            (otherDT->_handle == _handle));
    }

    virtual void operator() () const
    {
        _handle(_observer);
    }

private:
    T* _observer;
    ObserverHandle<T> _handle;
};

class Event
{
public:
    template <typename T>
    void add(T* observer, ObserverHandle<T> handle)
    {
        _observers.push_back(shared_ptr<BaseDelegate>(new Delegate<T>(observer, handle)));
    }

    template <typename T>
    void remove(T* observer, ObserverHandle<T> handle)
    {
        // I should be able to come up with a bind2nd(equals(dereference(_1))) kind of thing, but I can't figure it out now
        Observers::iterator it = find_if(_observers.begin(), _observers.end(), Compare(Delegate<T>(observer, handle)));
        if (it != _observers.end())
        {
            _observers.erase(it);
        }
    }

    void operator()() const
    {
        for (Observers::const_iterator it = _observers.begin();
            it != _observers.end();
            ++it)
        {
            (*(*it))();
        }
    }

private:
    typedef list<shared_ptr<BaseDelegate>> Observers;
    Observers _observers;

    class Compare
    {
    public:
        Compare(BaseDelegate const& other)
            : _other(other)
        {
        }

        bool operator() (shared_ptr<BaseDelegate> const& other) const
        {
            return (*other) == _other;
        }

    private:
        BaseDelegate const& _other;
    };
};

// Example usage:

class SubjectA
{
public:
    Event event;

    void do_event()
    {
        cout << "doing event" << endl;
        event();
        cout << "done" << endl;
    }
};

class ObserverA
{
public:
    void test(SubjectA& subject)
    {
        subject.do_event();
        cout << endl;

        subject.event.add(this, _observe);
        subject.do_event();
        subject.event.remove(this, _observe);
        cout << endl;

        subject.do_event();
        cout << endl;

        subject.event.add(this, _observe);
        subject.event.add(this, _observe);
        subject.do_event();
        subject.event.remove(this, _observe);
        subject.do_event();
        subject.event.remove(this, _observe);
        cout << endl;

    }

    void observe()
    {
        cout << "..observed!" << endl;
    }

private:
    static ObserverHandle<ObserverA> _observe;
};

// Here's the trick: make a static object for each method you might want to turn into a Delegate
ObserverHandle<ObserverA> ObserverA::_observe(boost::bind(&ObserverA::observe, _1));

int _tmain(int argc, _TCHAR* argv[])
{
    SubjectA sa;
    ObserverA oa;
    oa.test(sa);

    return 0;
}

И вот вывод:

выполнение события
готово

выполнение события
.. наблюдаемый!
готово

выполнение события
готово

выполнение события
.. наблюдаемый!
.. наблюдаемый!
готово
выполнение события
.. наблюдаемый!
готово

FAQ № 1 в документации функции повышения, кажется, рассматривает Ваш вопрос - и легкий ответ является "нет".

При хранении указателей функции только (и не другие функторы, которые соответствуют требуемой подписи), это легко (см. код ниже). Но в целом, ответ, как другие плакаты сказали, нет. В этом случае Вы, вероятно, хотите сохранить свои функторы в хеше как значения, при этом ключи - что-то пользовательские предоставления при добавлении и удалении.

Код ниже демонстрирует, как получить объект функтора/указателя, который нужно назвать. Для использования его необходимо знать точный тип объекта извлечь (т.е. typeid из типа Вы указываете, должен соответствовать typeid из содержавшего функтора/указателя).

#include <cstdio>
#include <functional>

using std::printf;
using std::tr1::function;

int main(int, char**);
static function<int (int, char**)> main_func(&main);

int
main(int argc, char** argv)
{
    printf("%p == %p\n", *main_func.target<int (*)(int, char**)>(), &main);
    return 0;
}

Что относительно

map<key-type, function<void (int)> > listeners;