Перегрузка и переопределение

Я немного запутался в двух терминологиях и был бы рад получить некоторые сомнения, разъясненные.

Как я понимаю function overloading означает наличие нескольких методов в одном классе с одним и тем же именем, но с разным количеством аргументов, разными типами аргументов или последовательностью аргументов, независимо от типа возврата, который не влияет на искаженное имя функции.

В приведенном выше определении также содержится ".... в том же классе или через связанные классы (связанные через наследование)....."

И Function Overriding связан с виртуальными функциями, одинаковой сигнатурой метода (объявлен виртуальной в базовом классе) и переопределен для реализации в подклассах.

Мне было интересно, сценарий, следующий код:

#include <iostream>

class A
{
    public:
    void doSomething(int i, int j)
    {
        cout<<"\nInside A::doSomething\n";
    }
};

class B: public A
{
    public:
    void doSomething(int i, int j)
    {
        cout<<"\nInside B::doSomething\n";

    }
};

int main()
{
    B obj;
    obj.doSomething(1,2);
    return 0;

}

В приведенном выше сценарии, что можно сказать:
Метод в методе производного класса overrides в базовом классе OR
Метод в методе производного класса overloads в базовом классе

Используется ли перегрузка в классах классов, а переопределяющий термин не обязательно применим к виртуальным функциям?

Я думаю, что это должно быть overrides, но просто нужно разъяснение, потому что я помню, что термин переопределение используется конкретно с виртуальными функциями.

Ответ 1

В этом случае ни один. Метод производного класса скрывает метод базового класса.

Ответ 2

скрытие - это когда определение в области видимости недоступно из-за объявления во вложенной области или производном классе (3.3.7/1).

Имя может быть скрыто явным объявлением того же имени во вложенной декларативной области или производном классе.

переопределение - это когда виртуальный член заменяется в производном классе (см. 10.3/2)

Если виртуальная функция-член vf объявлена в классе Base и в классе Derived, полученном прямо или косвенно из Base, объявлена функция-член vf с тем же именем и тем же списком параметров, что и Base:: vf, затем Derived:: vf также является виртуальным, и он переопределяет Base:: vf.

Перегрузка
заключается в том, что несколько объявлений сосуществуют для одного и того же имени в той же области (13/1)

Если для одного имени в одной и той же области указано два или более разных объявления, это имя считается перегруженным.

существует также возможность замены оператора new и удаления из стандартной библиотеки одной собственной реализацией (18.4.1.1.2, 18.4.1.1/6, 18.4.1.1/11, 18.4.1.2)

Итак, это, очевидно, случай сокрытия.

Ответ 3

Функция перегрузка - это когда у вас есть несколько функций, которые отличаются в списке параметров или, если они являются функциями-членами, в const/volatile квалификация. (В некоторых других языках вы также можете перегрузить на основе возвращаемого типа, но С++ этого не допускает.)
Примеры:

void f(int);
void f(char);

class some_class {
  void g();
  void g() const;
};

Функция переопределяет, когда вы переопределяете функцию базового класса с той же самой подписью. Обычно это имеет смысл только в том случае, если функция базового класса является виртуальной, поскольку в противном случае вызываемая функция (версия базового или производного класса) определяется во время компиляции с использованием статического типа reference/pointer. Примеры:

class base {
  void f();
  virtual void g();
};

class derived : public base {
  void f();
  void g();
};

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

class base {
  void f(int);
  void f(char);
};

class derived1 : public base {
  void f(double);
};

void f()
{
  derived1 d;
  d.f(42); // calls derived1::f(double)!
}

class derived2 : public base {
  using base::f; // bring base class versions into derived2 scope
  void f(double);
};

void g()
{
  derived2 d;
  d.f(42); // calls base::f(int)!
}

На всякий случай это неясно: на основе этих определений я бы назвал рассматриваемый сценарий здесь переопределяющим.

Ответ 4

Перегрузка - это процесс определения нескольких методов с одинаковыми именами, но с разными сигнатурами; Переопределение - это когда функция в дочернем классе имеет идентичную подпись с виртуальной функцией в родительском классе.

class Test {
  // Test::func is overloaded
  virtual void func(int x);
  virtual void func(double y);
};

class Child : public Test {
  // Child::func overrides Test::func
  virtual void func(int x); 
};