Вопрос по С++. Есть задача реализовать класс Handler, служащий для обработки некого события. При создании этого класса необходимо указывать обработчик (в данном случае это фунция exmpl_func). Как сделать, чтобы в качестве обработчика,при создании класса Handler использовался метод другого класса (например метод Catcher::func())

#include <stdio.h>

////////////////
class Handler
{
private:
    void (*pointer)();
public:
    Handler()
    {
        pointer = 0;
    };

    Handler(void (*p)())
    {
        pointer = p;
    };

    void peform(){
        if (pointer != 0)
            pointer();
    };

};

/////////////// функция, используемая для обработки
void exmpl_func()
{
        printf("\nSome function.");
}

///////////////
class Catcher{
    Handler *handler;
public:
    Catcher()
    {
        handler = new Handler(exmpl_func);
    };

    void func() // метод, что хотелось бы использовать
    {
    
    };

    void print()
    {
        printf("\nClass Catcher");
        if (handler != 0)
            handler->peform();
    };
};

void main()
{
    Catcher catcher;
    catcher.print();
}
Какие подобные механизмы можно использовать, чтобы это вписывалось в концепции ООП (например, можно было бы в качестве параметра передавать сам объект, но как учесть тот факт, что объекты могут быть разных классов). Поиогите хотя-бы несколькими фпазами, что можно сделать.
Спасибо.

• Подскажите механизм реализации.,naquad, 13:21 , 15-Июн-05
  • Подскажите механизм реализации.,naquad, 13:22 , 15-Июн-05
  • Подскажите механизм реализации.,_vladimir, 16:19 , 15-Июн-05
    • Подскажите механизм реализации.,alexander, 16:31 , 15-Июн-05
  • Подскажите механизм реализации.,rvs, 11:58 , 16-Июн-05

>Вопрос по С++. Есть задача реализовать класс Handler, служащий для обработки некого
>события. При создании этого класса необходимо указывать обработчик (в данном случае
>это фунция exmpl_func). Как сделать, чтобы в качестве обработчика,при создании класса
>Handler использовался метод другого класса (например метод Catcher::func())
>
>#include <stdio.h>
>
>////////////////
>class Handler
>{
>private:
> void (*pointer)();
>public:
> Handler()
> {
>  pointer = 0;
> };
>
> Handler(void (*p)())
> {
>  pointer = p;
> };
>
> void peform(){
>  if (pointer != 0)
>   pointer();
> };
>
>};
>
>/////////////// функция, используемая для обработки
>void exmpl_func()
>{
>  printf("\nSome function.");
>}
>
>///////////////
>class Catcher{
> Handler *handler;
>public:
> Catcher()
> {
>  handler = new Handler(exmpl_func);
> };
>
> void func() // метод, что хотелось бы использовать
> {
>
> };
>
> void print()
> {
>  printf("\nClass Catcher");
>  if (handler != 0)
>            handler->peform();
> };
>};
>
>
>
>void main()
>{
> Catcher catcher;
> catcher.print();
>}
>Какие подобные механизмы можно использовать, чтобы это вписывалось в концепции ООП (например,
>можно было бы в качестве параметра передавать сам объект, но как
>учесть тот факт, что объекты могут быть разных классов). Поиогите хотя-бы
>несколькими фпазами, что можно сделать.
>Спасибо.

Многоуважаемый, во-первых, зачем изобретать велосипед? Всё уже изобрели до нас: http://libsigc.sourceforge.net/ , а во-вторых, Символ какого-то класса это: RetType(ClassName::)(Params), а глобальная функция это: RetType(*)(Params). Существует возможность преобразования члена класса к RetType(*)(Params), но он должен быть СТАТИЧЕН! Иначе:
test.cpp:16: error: invalid use of non-static member function `void* Test::XXX(void*)'
test.cpp:16: error: invalid use of non-static member function
Вот такие вот пироги с котятами. Если вы найдёте способ как это решить, то я буду очень благодарен если поделитесь.

Извиняюсь, не символ, а функция.

Благодарю за проявленный интерес, но вопрос отпал сам собой (текст и названия классов изменились, но суть осталась прежней):
#include <stdio.h>

#define BYTE char
class Handler{
public:
  Handler(){};

  virtual void handler() = 0;    // будущий обработчик

  void intro(){  // точка входа в обработчик события.
    (this->*handler)();
  }; // здесь осуществляется вызов внешнего метода (служащего обработчиком) через указатель
};

////////////////////////////////////

class A: public Handler{
public:
    A(){};
    void handler(){printf("\nA.func");};
};

class ExtInt: public Handler{
public:

    ExtInt(){};
    ~ExtInt(){};
    virtual void setHandler(char, Handler *) = 0;    

    virtual void portHandler() = 0;                    // сюда попадаем от внещнего прерывания

    virtual void handler() = 0;
};

class ExtInt1: public ExtInt{
private:
Handler *handlers[8];    // массив указателей обработчиков,
// закрепленных за каждым каналом (битом) Порта 1
public:
  ExtInt1();
  ~ExtInt1();
  void setHandler(BYTE, Handler *);
  void enableInt(BYTE);
  void disableInt(BYTE);
  void portHandler();
  void handler();
};

ExtInt1::ExtInt1()
{
  char i;
  for (i = 0; i < 8; i++)
    handlers[i] = 0;
}

ExtInt1::~ExtInt1()
{
}

void ExtInt1::setHandler(char pin, Handler *ph)    // установим соответствие: номер пина - объект-обработчик события
{
    handlers[pin] = ph;                        // заполним ячейку объектом
};

void ExtInt1::enableInt(BYTE pin)
{
}

void ExtInt1::disableInt(BYTE pin)
{
}

void ExtInt1::portHandler() // сюда попадаем от внещнего прерывания
{
char c = 1;    
if (handlers[c] != NULL)    // обработчик события должен существовать
handlers[c]->intro();    // передаем управление точке входа
}

void ExtInt1::handler()
{
printf("\nExtInt.handler()");
}
/////////////////////////////////

void main()
{
    A a;
    ExtInt1 extint1;
    extint1.setHandler(1, &a);
    extint1.portHandler();
    extint1.setHandler(1, &extint1);
    extint1.portHandler();
}

внешнее прерывание что вроде (это писано вообще для микроконтроллеров MSP430 в среде IAR):

/**
* Этот объект используется для работы с внешним прерыванием (Порт 1)
*
*/
extern   ExtInt1 extint1;
/**
* Процедура обработки внешнего преравания (Порт 1)
* Передает управление методу класса ExtInt1::portHandler()
*/
#pragma vector=PORT1_VECTOR
__interrupt  void Port1()
{
  extint1->portHandler();
}

Можно вообще отказаться от виртуальныx функций и использовать библиотеку сигналов как было предложено выше
Рекомендую boost (http://boost.org/doc/html/signals.html) там ещё много интересных вещей есть

Когда-то писал такой обработчик.
Чтобы вызвать функцию член можно воспользоваться обобщенным функтором

Пример из кода

typedef Functor< void,TYPELIST_2(int,int)> Handler;
                
class Handlers
{
    

    public:
        Handlers(fltk::Widget *w,const Handler& h);
        Handlers();

        int add_handler(fltk::Widget *w,const Handler& h);

    private:
        
        struct Handler_info
        {
            Handler handler;
            fltk::Widget* wdt;
        };

        static std::list<Handler_info> _handler_list;
        static void default_callback(fltk::Widget* w,long l);
        static int _next_handler_id;

        void to_callback(fltk::Widget *w,const Handler& h);

};

std::list<Handlers::Handler_info> Handlers::_handler_list;
int Handlers::_next_handler_id = 1;
//--------------------------------------------------------------
Handlers::Handlers()
{
}
//---------------------------------------------------------------
//---------------------------------------------------------------
int Handlers::add_handler(fltk::Widget *w,const Handler& h)
{
    to_callback(w,h);
    return _next_handler_id++;
}
//----------------------------------------------------------------
void Handlers::to_callback(fltk::Widget *w,const Handler& h)
{
    assert(w);

    Handler_info hi;
    hi.handler = h;
    hi.wdt = w;

    _handler_list.push_back(hi);

    w->callback(&Handlers::default_callback);

    
}
//----------------------------------------------------------------
void Handlers:: default_callback(fltk::Widget* w,long l)
{

    for(std::list<Handler_info>::iterator i = _handler_list.begin(); i!= _handler_list.end(); ++i)
    {
        if(w == i->wdt)
            i->handler(w,l);
    }

    

    
}

Используем так:

class Main_panel
{
void exit(fltk::Widget*,long);

};

void foo()
{
      Handlers handlers;
    handlers.add_handler(exit,Handler(this,Main_panel::exit));

}