B>А вот VC7.1 даже не поперхнулся

class C
{
    typedef int pfn(int, int);
    pfn z;
};

int C::z(int, int)
{
    return 0;
}

>
> class Base { virtual foo() = 0; }
> class Derived : public Base { virtual foo() {}; }
> class Derived1, Derived2, ..., DerivedN : public Derived ;
>
>

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

  class Base { public: virtual foo() = 0; }

  class Derived : public Base { protected: __foo() {}; }

  class Derived1, Derived2, ..., DerivedN : public Derived
  {
    public: virtual foo(){Derived::__foo()}
  }

B>

[Note: a member function can be declared (but not defined) using a typedef for a function type. The resulting
member function has exactly the same type as it would have if the function declarator were provided
explicitly, see 8.3.5. For example,

typedef void fv(void);
typedef void fvc(void) const;
struct S {
fv memfunc1; // equivalent to: void memfunc1(void);
void memfunc2();
fvc memfunc3; // equivalent to: void memfunc3(void) const;
};
fv S::* pmfv1 = &S::memfunc1;
fv S::* pmfv2 = &S::memfunc2;
fvc S::* pmfv3 = &S::memfunc3;

Also see 14.3. ]

class C
{
public:
    typedef int pfn(int x, int y);
    
    pfn z
    {
        return x + y;
    }
};

L_L>>>Второе

C>>это радует

L_L>Опять какая-нить черная магия?

#define virtual(result_t, name) \
    virtual name##_t name; \
    typedef result_t name##_t
    
class Test
{
    virtual(int, foo)(int x, int y);
};

class C
{
    typedef int pfn(int, int);
    pfn z;
};

int C::z(int, int)
{
    return 0;
}

class C
{
    typedef int pfn(int, int);
    pfn z;
};

//well-formed
int C::z(int, int)
{
    return 0;
}

//ill-formed
C::pfn C::z
{
    return 0;
}

class Base
{
public:
    typedef int foo_t(int, double);
    virtual foo_t foo;
};

class Derived : public Base
{
public:
    virtual foo_t foo;
};

int Derived::foo(int x, double z)
{
    return 0;
}