Безопасен ли static_cast для полиморфных классов?

#include <iostream>
#include <boost/variant.hpp>
 
enum Type
{
    Int,
    Double,
    Char
};
 
struct IntT
{
    int n;
};
 
struct DoubleT
{
    double d;
};
 
struct CharT
{
    char c;
};
 
using VariantBody = boost::variant<IntT, DoubleT, CharT>;
 
struct Example
{
    Type mType;
    VariantBody mBody;
};
 
int main()
{
    std::cout << "Hello, world!\n";
    
    Example ex;
    
    {
        ex.mType = Type::Int;
        boost::get<IntT>(ex.mBody);
    }
    
    if (ex.mType == Type::Int)
    {
        const auto & body = boost::get<IntT>(ex.mBody).n = 10;
        std::cout << "body: " << body << "\n";
    }
}

#include <iostream>
 
enum Type
{
    Null,
    Int,
    Double,
    Char
};
 
struct BaseDummy
{
    BaseDummy(Type type = Type::Null)
        :
        mType(type)
    {}
 
    virtual ~BaseDummy() {}
    
    Type getType() const
    {
        return mType;
    }
    
protected:
    Type mType;
};
 
struct IntT : public BaseDummy
{
    IntT()
        :
        BaseDummy(Type::Int),
        n(0)
    {}
 
    int n;
};
 
struct DoubleT : public BaseDummy
{
    DoubleT()
        :
        BaseDummy(Type::Double),
        d(0)
    {}
 
    double d;
};
 
struct CharT : public BaseDummy
{
    CharT()
        :
        BaseDummy(Type::Char),
        c(0)
    {}
 
    char c;
};
 
struct Example
{
    BaseDummy mBody;
};
 
int main()
{
    std::cout << "Hello, world!\n";
    
    Example ex;
    
    {
        ex.mBody = IntT();
    }
    
    if (ex.mBody.getType() == Type::Int)
    {
        const auto & body = static_cast<IntT&>(ex.mBody).n = 10;
        std::cout << "body: " << body << "\n";
    }
}