Jakie są różnice między nadpisywaniem funkcji wirtualnych a ukrywaniem funkcji nie wirtualnych?

Czym jest ukrywanie funkcji?

... jest formą ukrywania imienia. Prosty przykład:

void foo(int);
namespace X
{
    void foo();

    void bar()
    {
        foo(42); // will not find `::foo`
        // because `X::foo` hides it
    }
}

Dotyczy to również wyszukiwania nazwy w klasie bazowej:

class Base
{
public:
    void foo(int);
};

class Derived : public Base
{
public:
    void foo();
    void bar()
    {
        foo(42); // will not find `Base::foo`
        // because `Derived::foo` hides it
    }
};

Co to jest funkcja nadrzędna?

JeÅ›li wirtualna funkcja member vf jest zadeklarowana w klasie Base i w klasie Derived, wywodzÄ…cej siÄ™ bezpoÅ›rednio lub poÅ›rednio z Base, to funkcja member vf o tym samym nazwa, parametr-type-list, CV-qualification i ref-qualifier (lub brak tego samego) jak Base::vf jest zadeklarowana, wtedy Derived::vf jest również wirtualny (niezależnie od tego, czy jest tak zadeklarowana) i nadpisuje Base::vf.

class Base
{
private:
    virtual void vf(int) const &&;
    virtual void vf2(int);
    virtual Base* vf3(int);
};

class Derived : public Base
{
public: // accessibility doesn't matter!
    void vf(int) const &&; // overrides `Base::vf(int) const &&`
    void vf2(/*int*/);     // does NOT override `Base::vf2`
    Derived* vf3(int);     // DOES override `Base::vf3` (covariant return type)
};

Ostateczne nadpisanie staje się istotne podczas wywoływania funkcji wirtualnej: [class.virtual] / 2

Wirtualna funkcja member C::vf obiektu klasy S jest ostatecznym nadrzÄ™dnym, chyba że najbardziej pochodna klasa, z której S jest podrzÄ™dnym obiektem klasy bazowej (jeÅ›li any) deklaruje lub dziedziczy innÄ… funkcjÄ™ czÅ‚onkowskÄ…, która nadpisuje vf.

Tzn. jeÅ›li masz obiekt typu S, ostateczne nadpisanie jest pierwszym nadpisaniem, które widzisz podczas przechodzenia hierarchii klas S z powrotem do klas bazowych. Ważne jest to, że Typ dynamiczny wyrażenia wywoÅ‚ania funkcji jest używany w celu okreÅ›lenia ostatecznego nadpisania:

Base* p = new Derived;
p -> vf();    // dynamic type of `*p` is `Derived`

Base& b = *p;
b  . vf();    // dynamic type of `b` is `Derived`

Jaka jest różnica między nadrzędnym a ukrywasz się?

Zasadniczo funkcje w klasie bazowej są zawsze ukryte przez funkcje o tej samej nazwie w klasie pochodnej; bez względu na to, czy funkcja w klasie pochodnej nadpisuje wirtualną funkcję klasy bazowej, czy nie:

class Base
{
private:
    virtual void vf(int);
    virtual void vf2(int);
};

class Derived : public Base
{
public:
    void vf();     // doesn't override, but hides `Base::vf(int)`
    void vf2(int); // overrides and hides `Base::vf2(int)`
};

Aby znaleźć nazwę funkcji, używany jest statyczny typ wyrażenia:

Derived d;
d.vf(42);   // `vf` is found as `Derived::vf()`, this call is ill-formed
            // (too many arguments)

Jak mają się one do przeciążeń funkcji?

Jako że "ukrywanie funkcji" jest formą ukrywania nazw, wszystkie przeciążenia mają wpływ, jeśli nazwa funkcji jest ukryty:

class Base
{
private:
    virtual void vf(int);
    virtual void vf(double);
};

class Derived : public Base
{
public:
    void vf();     // hides `Base::vf(int)` and `Base::vf(double)`
};

Dla nadpisywania funkcji, tylko funkcja w klasie bazowej z tymi samymi argumentami będzie nadpisywana; można oczywiście przeciążać funkcję wirtualną:

class Base
{
private:
    virtual void vf(int);
    virtual void vf(double);
    void vf(char);  // will be hidden by overrides in a derived class
};

class Derived : public Base
{
public:
    void vf(int);    // overrides `Base::vf(int)`
    void vf(double); // overrides `Base::vf(double)`
};