Каковы различия между переопределением виртуальных функций и сокрытием не виртуальных функций?

Что такое скрытие функций?

… это форма сокрытия имени. Простой пример:

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

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

Это также относится к поиску имени в базовом классе:

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
}
};

Что такое переопределение функции?

Это связано с концепцией виртуальных функций. [Class.virtual] / 2

Если функция виртуального члена vf объявлен в классе Base и в классе Derivedпрямо или косвенно Base, функция-член vf с тем же именем, параметром-списком типов, cv-квалификацией и ref-квалификатором (или отсутствием того же), что и Base::vf объявлен, то Derived::vf также является виртуальным (независимо от того, так ли это объявлено), и это Переопределение 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)
};

Окончательный переопределение становится актуальным при вызове виртуальной функции: [class.virtual] / 2

Виртуальная функция-член C::vf объекта класса S является окончательным переопределением, если самый производный класс которого S подобъект базового класса (если есть) объявляет или наследует другую функцию-член, которая переопределяет vf,

То есть если у вас есть объект типа Sокончательный переопределение — это первое переопределение, которое вы видите при обходе иерархии классов S вернуться к своим базовым классам. Важным моментом является то, что динамический тип выражения вызова функции используется для определения окончательного переопределения:

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

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

В чем разница между переопределением и сокрытием?

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

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)`
};

Чтобы найти имя функции, используется статический тип выражения:

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

Как они связаны с перегрузками функций?

Поскольку «скрытие функции» является формой сокрытия имени, все перегрузки затрагиваются, если имя функции скрыто:

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)`
};

Для переопределения функции будет переопределена только функция в базовом классе с теми же аргументами; Вы можете, конечно, перегрузить виртуальную функцию:

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)`
};