Можно ли создать массив в котором с 0 по 4 элемент будут храниться double, с 5 по 9 будут храниться int и т.д.?

#include <iostream>
 
struct base
{
    virtual const char* msg() const noexcept { return "base"; }
};
 
struct der: base
{
    virtual const char* msg() const noexcept 
    { 
        static_assert(
            sizeof(der) == sizeof(base),
            "invalid size"
        );
        
        return "der"; 
    }
};
 
struct bro: base
{
    virtual const char* msg() const noexcept  
    { 
        static_assert(
            sizeof(der) == sizeof(base),
            "invalid size"
        );
        return "bro"; 
    }
};
 
int main()
{
    base array[3];
    
    new(array + 0) base;
    new(array + 1) der;
    new(array + 2) bro;
    
    // --- теперь массив и без всяких union хранит объекты 
    // --- принципиально различных типов
 
    for(const auto& el: array)
        std::cout << el.msg() << '\n';
}

#include <iostream>
 
struct base
{
    virtual const char* msg() const noexcept { return "base"; }
};
 
struct der: base
{
    virtual const char* msg() const noexcept 
    { 
        static_assert(
            sizeof(der) == sizeof(base),
            "invalid size"
        );
        
        return "der"; 
    }
};
 
struct bro: base
{
    virtual const char* msg() const noexcept  
    { 
        static_assert(
            sizeof(der) == sizeof(base),
            "invalid size"
        );
        return "bro"; 
    }
};
 
int main()
{
    char array[ sizeof(base) * 3];
    
    new(array) base;
    new(array + sizeof(base)) der;
    new(array + sizeof(base) * 2) bro;
    
    base* base_obj = (base*)array;
    base* der_obj  = ((base*)array) + 1;
    base* bro_obj  = ((base*)array) + 2;
    
    std::cout << base_obj->msg() << '\n';
    std::cout << der_obj->msg() << '\n';
    std::cout << bro_obj->msg() << '\n';
}

#include <iostream>
 
using namespace std;
 
struct Base {
    virtual bool isDouble() { return false; }
    virtual bool isInt() { return false; }
    virtual bool isBool() { return false; }
};
 
struct Double : public Base {
    bool isDouble() override { return true; }
    Double(double d) : value(d) {}
    double value;
};
 
struct Int : public Base {
    bool isInt() override { return true; }
    Int(int i) : value(i) {}
    int value;
};
 
struct Bool : public Base {
    bool isBool() override { return true; }
    Bool(bool b) : value(b) {}
    bool value;
};
 
int main()
{
    Base *array[3];
    array[0] = new Int(10);
    array[1] = new Bool(true);
    array[2] = new Double(3.14);
 
    for (Base *base : array) {
        if (base->isBool()) {
            printf("%s\n", static_cast<Bool*>(base)->value ? "true" : "false");
        }
        else if (base->isInt()) {
            printf("%d\n", static_cast<Int*>(base)->value);
        }
        else if (base->isDouble()) {
            printf("%.2f\n", static_cast<Double*>(base)->value);
        }
    }
 
    return 0;
}

#include <iostream>
 
using namespace std;
 
struct Base {
    virtual bool isDouble() { return false; }
    virtual bool isInt() { return false; }
    virtual bool isBool() { return false; }
    void *value;
};
 
struct Double : public Base {
    bool isDouble() override { return true; }
    Double(double d) { value = new double(d); }
    ~Double() { delete static_cast<double*>(value); }
};
 
struct Int : public Base {
    bool isInt() override { return true; }
    Int(int i) { value = new int(i); }
    ~Int() { delete static_cast<int*>(value); }
};
 
struct Bool : public Base {
    bool isBool() override { return true; }
    Bool(bool b) { value = new bool(b); }
    ~Bool() { delete static_cast<bool*>(value); }
};
 
int main()
{
    Base *array[3];
    array[0] = new Int(10);
    array[1] = new Bool(true);
    array[2] = new Double(3.14);
 
    for (Base *base : array) {
        if (base->isBool()) {
            printf("%s\n", *static_cast<bool*>(base->value) ? "true" : "false");
        }
        else if (base->isInt()) {
            printf("%d\n", *static_cast<int*>(base->value));
        }
        else if (base->isDouble()) {
            printf("%.2f\n", *static_cast<double*>(base->value));
        }
    }
 
    return 0;
}

#include <iostream>
 
using namespace std;
 
struct Double;
struct Int;
struct Bool;
 
struct Base {
    virtual Double *asDouble() { return nullptr; }
    virtual Int *asInt() { return nullptr; }
    virtual Bool *asBool() { return nullptr; }
};
 
struct Double : public Base {
    Double *asDouble() override { return this; }
    Double(double d) : value(d) {}
    double value;
};
 
struct Int : public Base {
    Int *asInt() override { return this; }
    Int(int i) : value(i) {}
    int value;
};
 
struct Bool : public Base {
    Bool *asBool() override { return this; }
    Bool(bool b) : value(b) {}
    bool value;
};
 
int main()
{
    Base *array[3];
    array[0] = new Int(10);
    array[1] = new Bool(true);
    array[2] = new Double(3.14);
 
    for (Base *base : array) {
        if (base->asBool()) {
            printf("%s\n", base->asBool()->value ? "true" : "false");
        }
        else if (base->asInt()) {
            printf("%d\n", base->asInt()->value);
        }
        else if (base->asDouble()) {
            printf("%.2f\n", base->asDouble()->value);
        }
    }
 
    return 0;
}