Можно ли массив класса родителя заполнить классами наследниками без потери свойств и методов у наследников?

#include <iostream>
#include <type_traits>
 
#define NDEBUG // assert killer should be before #include <cassert>
 
#include <cassert>
 
using namespace std;
 
struct Base
{
 
    virtual void vf(){cout<<"Base\n";}
    virtual ~Base(){}
};
 
struct Derived :public Base
{
    void vf(){cout<<"Derived\n";}
    int a=123;
    int get_a(){return a;}
    ~Derived(){};
};
 
void foo(Base** arrayPtrBase, size_t n)
{
   cout<<"there\n";
 for(size_t i=0; i<n; ++i)arrayPtrBase[i]->vf();
}
 
void foo(Derived** arrayPtr, size_t n)
{
     cout<<"here\n";
 for(size_t i=0; i<n; ++i)arrayPtr[i]->vf();
}
int count(0);
template <size_t sizeOfArray, class Base_type, class Derived_type>
struct ArrayWrapper
{
        typedef  Derived_type * (&DerrArray_ptrs_type)[sizeOfArray] ;
        typedef  Base_type * (&BaseArray_ptrs_type)[sizeOfArray] ;
 
    ArrayWrapper(DerrArray_ptrs_type derrArray_)
    :derrArray(derrArray_)
    {}
 
    operator  BaseArray_ptrs_type ()
        {
            cout<<"operator  BaseArray_ptrs_type\n";
            if(count++)cin.get();
            return *this ;
        }
 
    Base_type * operator  [] (size_t ind)
    {
        cout<<"operator  []\n";
        return derrArray[ind] ;
    } ;
    enum {Size=sizeOfArray};
    DerrArray_ptrs_type derrArray ;
};
 
int main()
{
 
Base bs1, bs2;
Derived dr1, dr2;
 
Base base_mixed[]={bs1, bs2, dr1, dr2};//как видите компилируется
Derived *pd=static_cast<Derived *>(&base_mixed[0]);
cout<<pd->a<<endl;//boom
cout<<pd->get_a()<<endl;//bada_boom
cout<<"\n_huh__\n";
 
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<sizeof(ar_der)/sizeof(Derived *), Base, Derived>
 arrayWrapper(ar_der);
 
 
cout<<"Somthing will happened\n" ;
 
foo(arrayWrapper, arrayWrapper.Size);
cin.get();
 
foo(ar_bas, sizeof(ar_bas)/sizeof(Base *));
cout<<endl;
foo(ar_bas_mix, sizeof(ar_bas_mix)/sizeof(Base *));
cout<<endl;
foo(ar_der, sizeof(ar_der)/sizeof(Derived *));
return 0;
}

if (dynamic_cast<Первый наследник*>(Элемент Родителя) != NULL)
    {
        /*Выполняем методы первого наследника через static_cast<Первый Наследник*>(Элемент Родителя)->МетодНаследника()*/
    }
    else
    {
        /*Выполняем методы второго наследника через static_cast<Второй Наследник*>(Элемент Родителя)->МетодНаследника()*/
    }