Размер указателя

struct Parent {
  void foo() {}
};

struct Parent {
  void foo() {}
};
 
struct Child : Parent {
};
 
int main() {
  void (Child::*p)() = &Child::foo; // &Child::foo - это void (Parent::*)()
  Child o;
  (o.*p)();
}

struct Parent {
};
 
struct Child : Parent {
  void foo() {}
};
 
int main() {
  void (Parent::*p)() = static_cast<void (Parent::*)()>(&Child::foo);
  Child co;
  Parent *po = &co;
  (po->*p)();
}

#include <iostream>
class Foo;
void (Foo::*p)();//Определите, есть ли здесь множественное наследование
 
class Foo
{
public:
    void foo()
    {
        std::cout << "foo";
    }
};
int main()
{
    Foo foo;
    p = &Foo::foo;
    (foo.*p)();
}

struct Rhombus;
void (Rhombus::*p)();
 
struct A
{
    void foo(){}
};
 
struct B:virtual A
{
};
 
struct C:virtual A
{
};
 
struct Rhombus:B,C
{
};
 
int main()
{
    Rhombus rhombus;
    A*a=&rhombus;//работает
    p=static_cast<void(Rhombus::*)()>(&A::foo);//не работает
    return 0;
}

class A
{
    int i;
public:
    A() : i(1) {}
    void foo() { std::cout << i; }
};
class B : public A
{
    int i;
public:
    B() : i(2) {}
    void foo() { std::cout << i; }
};
class C : public B
{
    int i;
public:
    C() : i(3) {}
    void foo() { std::cout << i; }
};
 
void callFoo(C& c, void (C::*ptr)())
{
    (c.*ptr)(); // Что здесь откуда вычитать, если вы не храните ptrdiff
}
 
int main()
{
    C c;
    callFoo(c, &A::foo);
    callFoo(c, &B::foo);
    callFoo(c, &C::foo);
}

int main()
{
    C c;
    if((void*)static_cast<A*>(&c) == (void*)&c &&
            (void*)static_cast<B*>(&c) == (void*)&c)
        cout<<"Что здесь откуда вычитать, если преобразования НЕ меняют указатель?"<<endl;
    callFoo(c, &A::foo);
    callFoo(c, &B::foo);
    callFoo(c, &C::foo);
}

#include <iostream>
 
using namespace std;
 
class C;
class A
{
    int i;
public:
    A() : i(1) {}
    void _foo() { std::cout << i; }
    static void foo(C*_this);
};
class B : public A
{
    int i;
public:
    B() : i(2) {}
    void _foo() { std::cout << i; }
    static void foo(C*_this);
};
class C : public B
{
    int i;
public:
    C() : i(3) {}
    void _foo() { std::cout << i; }
    static void foo(C*_this);
};
 
void A::foo(C *_this){static_cast<A*>(_this)->_foo();}
void B::foo(C *_this){static_cast<B*>(_this)->_foo();}
void C::foo(C *_this){static_cast<C*>(_this)->_foo();}
 
void callFoo(C& c, void (*ptr)(C*))
{
    (*ptr)(&c);
}
 
int main()
{
    C c;
    callFoo(c, &A::foo);
    callFoo(c, &B::foo);
    callFoo(c, &C::foo);
}