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

#include <iostream>
#include <vector>
 
struct base
{
    virtual ~base(){}
    
    virtual void foo() { std::cout << "base::foo\n"; }
    int v = 33;
};
    
struct der: base
{
    virtual ~der(){}
    
    virtual void foo() { std::cout << "der::foo\n"; }
    int v[255];
};
 
    
void foo(base** arr)
{
    for(size_t i = 0; i != 3; ++i)
    {
        arr[i]->foo();
        delete arr[i];
    }
}
 
int main()
{
   
    der* arr[] = { new der(), new der(), new der() };
    foo( reinterpret_cast<base**>(arr) );
}

#include <iostream>
 
struct base
{
    virtual ~base(){}
    
    virtual void foo() { std::cout << "base::foo\n"; }
    int v = 33;
};
    
struct der: base
{
    virtual ~der(){}
    
    virtual void foo() { std::cout << "der::foo\n"; }
    int v[255];
};
 
    
void foo(base* arr)
{
    for(size_t i = 0; i != 3; ++i)
        arr[i].foo();  // errror
}
 
int main()
{
    der d;
   
    der arr[] = { d, d, d };
    
    base* b = arr; // ok
 
    foo(b); // алгоритм будет думать, что ему передали массив base
    // хотя на самом деле это массв der, размер которых гораздо больше
    // в результате начало очередного объекта der будет вычисленно неверно
    // последствия - не определены. скорее всего - авария.
}

#include <iostream>
#include <vector>
 
struct base1
{
    virtual ~base1(){}
    
    virtual void foo() { std::cout << "base1::foo\n"; }
    int v = 33;
};
 
struct base2
{
    virtual ~base2(){}
    
    virtual void baz() { std::cout << "base2::baz\n"; }
    
    int v[255];
};
 
    
struct der: base2, base1
{
    virtual ~der(){}
    
    virtual void foo() { std::cout << "der::foo\n"; }
    int v[255];
};
 
    
void foo(base1** arr)
{
    for(size_t i = 0; i != 3; ++i)
    {
        arr[i]->foo();
        delete arr[i];
    }
}
 
int main()
{
   
    der* arr[] = { new der(), new der(), new der() };
 
    foo( reinterpret_cast<base1**>(arr) );  //ре-интерпритация
    // в отличие от легального преобразования типов
    // не делает поправку на смещение к подобъекту базового класса
 
    // алгоритм будет думать что по адресу находится base1,
    // хотя на самом деле там находится подобъект base2
}