Итак: знаю, что вопрос обсуждался — честно перерыл весь RSDN, но применить так и не сумел.

Дело в следующем:

class Base{
   // Что-то там...
};

class A : public Base {
   // Что-то там...
   void fA();
};

class B : public Base {
   // Что-то там...
   void fB();
};

class D{
   void fD( /* вот тут-то и вопрос */ );
};

Вот тут-то и вопрос:
Как передать указатель на fA() и fB()?

Здравствуйте, BabySG, Вы писали:

BSG>Вот тут-то и вопрос:
BSG>Как передать указатель на fA() и fB()?

Передать — куда и зачем? Вопрос поставлен довольно туманно.

Здравствуйте, Alxndr, Вы писали:

A>Здравствуйте, BabySG, Вы писали:

BSG>>Вот тут-то и вопрос:
BSG>>Как передать указатель на fA() и fB()?

A>Передать — куда и зачем? Вопрос поставлен довольно туманно.

Передать в fD() сначала указатель на fA(), потом на fB()...

знаю 2 способа

1 см boost::bind или boost::mem_fn
2 сделать fD что-то вроде

template <class TOwner> void fD(TOwner* pOwner,void(TOwner::* func)(void))
{
    (pOwner->*func)();
}

Здравствуйте, Матвей Жданович, Вы писали:

МЖ>2 сделать fD что-то вроде
МЖ>

МЖ>template <class TOwner> void fD(TOwner* pOwner,void(TOwner::* func)(void))
МЖ>{
МЖ>    (pOwner->*func)();
МЖ>}
МЖ>

Великолепно! То, что надо! Спасибо! Решает все вопросы.

Здравствуйте, BabySG, Вы писали:

BSG>Здравствуйте, Матвей Жданович, Вы писали:

МЖ>>2 сделать fD что-то вроде
МЖ>>

МЖ>>template <class TOwner> void fD(TOwner* pOwner,void(TOwner::* func)(void))
МЖ>>{
МЖ>>    (pOwner->*func)();
МЖ>>}
МЖ>>

BSG>Великолепно! То, что надо! Спасибо! Решает все вопросы.

Так-с...

Задумался далее: в функцию я значения передал, НО!
Теперь мне эти значения нужно сохранить в массиве... Застрял опять... Мнения?

BSG>Так-с...

BSG>Задумался далее: в функцию я значения передал, НО!
BSG>Теперь мне эти значения нужно сохранить в массиве... Застрял опять... Мнения?

ну если нет религиозных причин не использовать boost то boost::function и boost::mem_fn решат все проблемы
если есть то можно наваять велосипед что-то вроде этого:

struct CAbstractFunctor
{
    virtual void operator()(){};
    virtual ~CAbstractFunctor(){};
};

template <class TOwner> struct CFunctor:public CAbstractFunctor
{
    TOwner* m_pOwner;
    void(TOwner::* m_pFunc)(void);
    CFunctor(TOwner* pOwner,void(TOwner::* func)(void)):m_pOwner(pOwner),m_pFunc(func){};
    virtual void operator()()
    {
        (m_pOwner->*m_pFunc)();
    };
};

struct D{    
    CAbstractFunctor* arr[2];
    template <class TOwner> void fD(TOwner* pOwner,void(TOwner::* func)(void),int i)
    {
        arr[i] = new CFunctor<TOwner>(pOwner,func);        
    }
    void DoIt(int i)
    {
        (*arr[i])();
    }
};

Надо только потом не забыть почистить память.
В любом случае написание таких велосипедов дело опасное и вообще говоря не нужное.