Чому перекрита функція у похідному класі приховує інші перевантаження базового класу?

Розглянемо код:

#include <stdio.h>

class Base {
public: 
    virtual void gogo(int a){
        printf(" Base :: gogo (int) \n");
    };

    virtual void gogo(int* a){
        printf(" Base :: gogo (int*) \n");
    };
};

class Derived : public Base{
public:
    virtual void gogo(int* a){
        printf(" Derived :: gogo (int*) \n");
    };
};

int main(){
    Derived obj;
    obj.gogo(7);
}

Отримав цю помилку:

> g ++ -педагогічний -Os test.cpp -випробування
test.cpp: У функції `int main () ':
test.cpp: 31: помилка: немає функції узгодження для виклику до `Виведеного :: gogo (int) '
test.cpp: 21: Примітка: кандидатами є: віртуальна порожнеча Отримано :: gogo (int *) 
test.cpp: 33: 2: попередження: у кінці файлу немає нового рядка
> Код виходу: 1

Тут функція класу Похідне затьмарює всі однойменні функції (не підписи) в базовому класі. Якось така поведінка C ++ не виглядає нормально. Не поліморфний.

Судячи з формулювання вашого запитання (ви вживали слово "сховатися"), ви вже знаєте, що тут відбувається. Явище називається «приховування імені». Чомусь кожен раз, коли хтось задає питання про те, чому трапляється приховування імені, люди, які відповідають або говорять, що це називається "приховування імені", і пояснюють, як воно працює (що ви, мабуть, вже знаєте), або пояснюють, як його переосмислити (що ви ніколи про це не питали), але, здається, ніхто не піклується про вирішення актуального питання "чому".

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

Наприклад, скажімо, базовий клас 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 між класами. Це правда, але, мабуть, тоді було вирішено, що врешті-решт приховування імені виявиться меншим злом.

Правила вирішення імен говорять, що пошук імен зупиняється на першій області, в якій знайдено відповідне ім'я. У цей момент починаються правила вирішення перевантаження, щоб знайти найкращу відповідність доступних функцій.

У цьому випадку, gogo(int*)він знаходиться (окремо) в області виведеного класу, і оскільки немає стандартного перетворення з int в int *, пошук не вдається.

Рішення полягає в тому, щоб ввести базові декларації за допомогою використовуючої декларації у класі Отримані:

using Base::gogo;

... дозволить правилам пошуку імен знайти всіх кандидатів, і, таким чином, рішення перевантаження буде тривати так, як ви очікували.

Це "За задумом". У розділі C ++ роздільна здатність перевантаження для цього типу методу працює наступним чином.

• Починаючи з типу посилання, а потім переходячи до базового типу, знайдіть перший тип, який має метод з назвою "gogo"
• Розглядаючи лише методи, названі "gogo" для цього типу, знаходять відповідне перевантаження

Оскільки в Derived немає функції узгодження під назвою "gogo", роздільна здатність перевантаження не вдається.

Приховування імен має сенс, оскільки це запобігає двозначності у вирішенні імен.

Розглянемо цей код:

class Base
{
public:
    void func (float x) { ... }
}

class Derived: public Base
{
public:
    void func (double x) { ... }
}

Derived dobj;

Якщо Base::func(float)це не було заховано Derived::func(double)в Derived, ми би викликали функцію базового класу під час виклику dobj.func(0.f), навіть незважаючи на те, що флоат може бути підвищений до подвійного.

Довідка: http://bastian.rieck.ru/blog/posts/2016/name_hiding_cxx/