Почему стандарт C ++ разрешает срез объектов?

Пожалуйста, не объясните мне концепцию среза объекта C ++, поскольку я это знал.

Мне просто интересно, какова цель этого дизайна функции c ++ (среза объекта)?

Чтобы новичок получил больше ошибок?

Разве это не было бы более безопасно для C ++, чтобы предотвратить срез объекта?

Ниже приведен только стандартный и базовый пример среза:

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
}

Заранее спасибо.

================================================== =============================== После прочтения всех ответов и комментариев, я думаю, что я должен в первую очередь лучше выразить свой вопрос но здесь это прибывает:

При наличии отношения is-a (публичное наследование) вместо частного / защищенного наследования вы можете сделать следующее:

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
}

Хорошо известно, что только 2 и 3 работают полиморфно, в то время как один - печально известная нарезка объектов, которая не производит ничего, кроме ошибки!

Примечание 1, 2 и 3НУЖНО это отношение к работе.
Если вы используете личное / защищенное наследование, вы получите ошибку компиляции для всех них:

'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

Так что мой вопрос (первоначальное намерение) заключался в том, чтобы спросить: будет ли лучше, если стандарт c ++ сделает 1 ошибку компиляции, продолжая разрешать 2 и 3?

Надеюсь, на этот раз я лучше выразил свой вопрос.

Спасибо