Восходящее преобразование массива производного класса к родительскому?

X* p = &y;

X* p = static_cast<X*>(&y);

#include <iostream>
 
struct base
{
    virtual ~base(){}
    virtual void foo(){ std::cout << "base::foo()\n"; }
    int v = 3;
};
 
struct der: base
{
    virtual void foo(){ std::cout << "der::foo()\n"; }
    int w[100];
};
 
 
int main()
{
    der d;
    der* p = &d;
    base* b = reinterpret_cast<base*>(p); // <--- не является similar 
    b->foo();
}

Base bs1, bs2;
Derived dr1, dr2;
Base base_mixed[]={bs1, bs2, dr1, dr2};//как видите компилируется

#include <iostream>
using namespace std;
 
struct Base
{
 
    virtual void vf(){cout<<"Base\n";}
    virtual void vf1(){cout<<"Base1\n";}
    virtual ~Base(){}
};
 
struct Derived :public Base
{
    void vf(){cout<<"Derived\n";}
     void vf1(){cout<<"Derived1\n";}
    int a=123;
    int get_a(){return a;}
    ~Derived(){};
};
 
struct arrayWrapper
{
    arrayWrapper(Derived ** pderived, size_t size)
    :m_pderived(pderived), m_size(size)
    {}
 
   Base * operator [](size_t ind)
    {
       return m_pderived[ind] ;
    }
 
    Derived **m_pderived;
    size_t m_size;
};
 
template <class T>
void foo(T arrayPtrBase, size_t n)
{
 for(size_t i=0; i<n; ++i)arrayPtrBase[i]->vf();
}
 
template <
class T,
class ArrElemType,
void (ArrElemType::*fn)()  >
void fun(T arrayPtrBase, size_t n)
{
 for(size_t i=0; i<n; ++i)(arrayPtrBase[i]->*fn)();
}
 
int main()
{
Base base, *pbase=&base;
Derived der1, der2, *pder1=&der1, *pder2=&der2;
Base *ar_bas[]={pbase, pbase,  pbase};
Base *ar_bas_mix[]={pbase, pder1,  pder2};
Derived *ar_der[]={pder1,  pder2, pder1,  pder2};
 
 
arrayWrapper arwr(ar_der, sizeof(ar_der)/sizeof(Derived *));
 
//без обёртки шаблон ест нормально тоже
foo(ar_der, sizeof(ar_der)/sizeof(Derived *));
cout<<endl;
foo(arwr, arwr.m_size);
cout<<endl;
foo(ar_bas, sizeof(ar_bas)/sizeof(Base *));
cout<<endl;
foo(ar_bas_mix, sizeof(ar_bas_mix)/sizeof(Base *));
cout<<endl;
//ужасный синтаксис
//когда смотришь на указатели на члены
//кажется что члены указывают в ответ...
cout<<"\nA teper - gorbatiy!\n"<<endl;
fun<decltype(ar_bas_mix), Base, &Base::vf>
(ar_bas_mix,  sizeof(ar_bas_mix)/sizeof(Base *));
cout<<endl;
fun<decltype(ar_bas_mix), Base, &Base::vf1>
(ar_bas_mix,  sizeof(ar_bas_mix)/sizeof(Base *));
 
return 0;
}