Почему переопределенный функционирует в производном классе, скрывают другие перегрузки базового класса?

Судя по формулировке вашего вопроса (вы использовали слово «скрыть»), вы уже знаете, что здесь происходит. Это явление называется «сокрытие имени». По какой-то причине каждый раз, когда кто-то задает вопрос о , почему происходит сокрытие имени , люди, которые отвечают, либо говорят, что это называется «скрытие имени», и объясняют, как это работает (что вы, вероятно, уже знаете), либо объясняют, как чтобы переопределить его (о чем вы никогда не спрашивали), но, похоже, никто не заботится о фактическом "почему" вопрос.

Решение, обоснование сокрытия имени, то есть , почему на самом деле было разработано на C ++, состоит в том, чтобы избежать определенного противоречивого, непредвиденного и потенциально опасного поведения, которое может иметь место, если унаследованный набор перегруженным функциям было разрешено смешиваться с текущим набором перегрузок в данном классе. Вы, наверное, знаете, что в C ++ разрешение перегрузки работает, выбирая лучшую функцию из набора кандидатов. Это делается путем сопоставления типов аргументов с типами параметров. Иногда правила сопоставления могут быть сложными и часто приводить к результатам, которые неподготовленный пользователь может воспринять как нелогичные. Добавление новых функций к набору ранее существовавших может привести к довольно резкому сдвигу в результатах разрешения перегрузки.

Например, пусть ' s говорят, что базовый класс B имеет функцию-член foo , которая принимает параметр типа void * , и все вызовы foo (NULL) разрешаются в B :: foo (void *) . Допустим, имя не скрывается, и этот B :: foo (void *) виден во многих различных классах, происходящих от B . Однако, допустим, в некотором [косвенном, удаленном] потомке D класса B определена функция foo (int) . Теперь, без скрытия имени D имеет видимые и участвующие в разрешении перегрузки как foo (void *) , так и foo (int) . В какую функцию будут разрешаться вызовы foo (NULL) , если сделано через объект типа D ? Они будут преобразованы в D :: foo (int) , поскольку int лучше подходит для целого нуля (то есть NULL ), чем любой тип указателя. Таким образом, во всей иерархии вызовы foo (NULL) разрешаются в одну функцию, а в D (и ниже) они внезапно разрешаются в другую.

Другой пример приведен в Дизайн и развитие C ++ , стр. 77:

class Base {
    int x;
public:
    virtual void copy(Base* p) { x = p-> x; }
};

class Derived{
    int xx;
public:
    virtual void copy(Derived* p) { xx = p->xx; Base::copy(p); }
};

void f(Base a, Derived b)
{
    a.copy(&b); // ok: copy Base part of b
    b.copy(&a); // error: copy(Base*) is hidden by copy(Derived*)
}

Без этого правила состояние b было бы частично обновлено, что привело бы к разрезанию.

Такое поведение было сочтено нежелательным. когда язык был разработан. В качестве лучшего подхода было решено следовать спецификации «сокрытия имени», означающей, что каждый класс начинается с «чистого листа» по отношению к каждому объявленному им имени метода. Чтобы переопределить это поведение, от пользователя требуется явное действие: первоначально повторное объявление унаследованных методов (в настоящее время не рекомендуется), теперь явное использование объявления-использования.

Как вы правильно заметили в своем исходном сообщении (Я имею в виду замечание «Не полиморфно»), такое поведение можно рассматривать как нарушение IS-A отношений между классами. Это правда, но, видимо, тогда было решено, что в конце концов сокрытие имени окажется меньшим злом.

такое поведение можно рассматривать как нарушение IS-A отношений между классами. Это правда, но, видимо, тогда было решено, что в конце концов сокрытие имени окажется меньшим злом.

такое поведение можно рассматривать как нарушение IS-A отношений между классами. Это правда, но, видимо, тогда было решено, что в конце концов сокрытие имени окажется меньшим злом.