Argument funkcji jako adres metody innej klasy

#include <iostream>

using namespace std;

// Ja Singleton robię tak...

template < class T >
class Singleton
{
private:
    Singleton( const Singleton & );
    Singleton & operator =( const Singleton & );
protected:
    Singleton()
    {
    }
    virtual ~Singleton()
    {
    }
public:
    static T & getInstance()
    {
        static T _instance;
        return _instance;
    }
};

class B
    : public Singleton < B >
{
protected:
    friend class Singleton < B >;
private:
    B() { } // Obiekt klasy też jest Singleton'em
public:
    void Draw()
    {
        cout << "Wywołanie metody Draw() z klasy B." << endl;
    }
};

class A
    : public Singleton < A >
{
protected:
    friend class Singleton < A >;
private:
    A() // Obiekt klasy to Singleton
    {
        //...
    }
    ~A()
    {
        //...
    }
public:
    // W typie arg. przekazywanego _powinna_ być klasa w której jest metoda.
    // Dopiero to tworzy kompletny typ.
    void MetodaKlasyA( void( B::* draw )() )
    {
        //...
        while( 1 ) {
            //...
            // Zapewne chodziło Ci o tę składnię :-)
            ( B::getInstance().* draw )();
            // Tu aby nie wykonywało w nieskończoność..
            exit( 0 );
           
            //...
        }
    }
};


// Funkcja main _zawsze_ zwraca int!
int main()
{
    //...
    A::getInstance().MetodaKlasyA( & B::Draw );
    //...
}