Неявное приведение указателей на классы

ExtIn      ABCD(0, 0);                       // Создали наш класс
ExtIn*    pABCD         = & ABCD;       // Создали указатель на наш класс.
IIn*       p_2_ABCD    = & ABCD;       // Такой указатель тоже создается.

ExtIn**   ppABCD      = & pABCD;      // Такой указатель создается
IIn**      pp_2_ABCD = & p_2_ABCD; // И вот такой создается
IIn**      pp_3_ABCD = & pABCD;      // А вот такой компилятор не хочет создавать ни в какую.
// пишет, что не может конвертировать ExtIn** в IIn**, хотя нормально конвертирует одинарный указатель (ExtIn* в IIn*)
// а вот принудительное приведение он понимает:
IIn**      pp_4_ABCD = (IIn**) & pABCD;  // Компилирует. Все его устраивает.

class Foo : public Bar {...};
Foo **********foo=GetSome();
Bar **********bar=foo;

class Foo
{
public:
    int foo;
}
class Bar : public Foo
{
public:
    int bar;
}
void f(Foo *** foo) {};
 
int main()
{
    Bar ***bar=GetpppBar();
    f(bar); //что сюда передавать?
}

#include <cstdio>
 
class A
{
public:
    int a;
 
    A(int a) : a(a) {}
};
 
class B
{
public:
    int b;
 
    B(int b) : b(b) {}
};
 
class C : public A, public B
{
public:
    int c;
 
    C(int c, int a, int b) : c(c), A(a), B(b) {}
};
 
int main()
{
    C c(1,2,3); // b == 3
    C * p = &c;
    B * r = &c;
    std::printf("%x - %x\n===\\\n", p, r);
    
    {
        B *  p1b = p;   // тот самый промежуточный указатель, о котором говорилось выше.
        B ** p2b = &p1b;
        
        std::printf("%x = %x\n", p2b, &p);
        
        std::printf("%d\n", (*p2b)->b);  //ok (b == 3)
    }
    {
        B ** p2b = (B **)&p;
        
        std::printf("%x = %x\n", p2b, &p);
        
        std::printf("%d\n", (*p2b)->b);  //fail
    }
}

class VasyaPupkin : public IIn {};
 
VasyaPupkin ya_vasya;
 
ExtIn *p_ext_in;
IIn **p_iin = &p_ext_in; // предположим это разрешено
*p_iin = &ya_vasya; // тут и так все в порядке

void f(int ****ptr)
{
    **ptr++; //Что мы будем здесь инкрементировать, если переменная одна.
}