¿Por qué el estándar C ++ permite el corte de objetos?

Por favor, no me explique el concepto de división de objetos de C ++ como lo sabía.

Me pregunto cuál es la intención detrás de este diseño de la función c ++ (división de objeto).

¿Para que el principiante tenga más errores?

¿No sería más seguro para C ++ evitar el corte de objetos?

Below es solo un ejemplo de segmento estándar y básico:

class Base{
public:
       virtual void message()
       {
               MSG("Base ");
       }
private:
    int m_base;
};

class Derived : public Base{
public:
       void message()
       {
               MSG("Derived "); 
       }
private:
       int m_derive;
};

int main (void)
{
    Derived dObj;

    //dObj get the WELL KNOWN c++ slicing below
    //evilDerivedOjb is just a Base object that cannot access m_derive
    Base evilDerivedOjb = dObj;  //evilDerivedObj is type Base
    evilDerivedOjb.message();    //print "Baes" here of course just as c++ standard says
}

Gracias por adelantado

================================================= ================================ Después de leer todas las respuestas y comentarios, creo que debería expresar mejor mi pregunta al principio lugar pero aquí viene:

Cuando haya una relación is-a (herencia pública), en lugar de una herencia privada / protegida, puede hacer lo siguiente:

class Base{
public:
    virtual void foo(){MSG("Base::foo");}
};

class Derived : public Base{
public:
    virtual void foo(){MSG("Derived::foo");}
};

int main (void)
{
    Base b;
    Derived d;
    b = d;                      //1
    Base * pB = new Derived();  //2
    Base& rB = d;               //3

    b.foo();    //Base::foo
    pB->foo();  //Derived::foo
    rB.foo();   //Derived::foo
}

¡Es bien sabido que solo 2 y 3 funcionan polimórficamente, mientras que uno es el infame rebanador de objetos que no produce más que un error!

Nota 1, 2 y 3NECESITA es una relación con el trabajo.
Si está utilizando una herencia privada / protegida, obtendrá un error de compilación para todos ellos:

'type cast' : conversion from 'Derived *' to 'const Base &' exists, but is inaccessible
'type cast' : conversion from 'Derived *' to 'Base *' exists, but is inaccessible
'type cast' : conversion from 'Derived *' to 'Base &' exists, but is inaccessible

Así que mi pregunta (intención original) era preguntar ¿sería mejor si el estándar c ++ hace que 1 sea un error de compilación mientras sigue permitiendo 2 y 3?

Espero haber expresado mi pregunta mejor esta vez.

Gracia