Рекомендуем, 2020

Выбор редакции

Разница между перегрузкой функций и переопределением в C ++

Полиморфизм является одной из важнейших особенностей ООП. Это просто означает «использование одного имени для нескольких форм». Полиморфизм может быть реализован с использованием «перегрузки функций», «перегрузки операторов» и «виртуальной функции». И «перегрузка», и «переопределение» подразумевают концепцию полиморфизма. Здесь «перегрузка» - это полиморфизм времени компиляции, а «переопределение» - полиморфизм времени исполнения. Учимся дальше, если говорить об основных различиях в «перегрузке» и «переопределении». В «перегрузке» мы переопределяем перегруженные функции с тем же именем функции, но с другим количеством и типом параметров. В «переопределении» прототип переопределенной функции одинаков во всей программе, но переопределяемой функции предшествует ключевое слово «virtual» в базовом классе, и он переопределяется производным классом без каких-либо ключевых слов.

Далее, мы изучаем разницу между перегрузкой и переопределением с помощью сравнительной таблицы.


Сравнительная таблица:

Основа для сравненияперегрузкаПереопределение
ПрототипПрототип отличается тем, что число или тип параметра могут отличаться.Все аспекты прототипа должны быть одинаковыми.
Ключевое словоКлючевое слово не применяется во время перегрузки.Функция, которая должна быть переопределена, предшествует ключевому слову «virtual» в базовом классе.
Отличительный факторНомер или тип параметра различаются, что определяет версию вызываемой функции.Какая функция класса вызывается указателем, определяется тем, какой адрес объекта класса назначен этому указателю.
Определение шаблонаФункция переопределена с тем же именем, но с другим номером и типом параметра.Функция определена, ей предшествует ключевое слово «virtual» в основном классе и переопределяется производным классом без ключевого слова.
Время выполненияВремя компиляции.Время выполнения
Конструктор / Виртуальная функцияКонструкторы могут быть перегружены.Виртуальная функция может быть переопределена.
Destructor
Деструктор не может быть перегружен.Деструктор может быть переопределен.
переплетПерегрузка достигает раннего связывания.Переопределение относится к позднему связыванию.

Определение перегрузки

Полиморфизм во время компиляции называется «перегрузкой». Поскольку перегрузка генерируется из концепции полиморфизма, она обеспечивает «общий интерфейс для нескольких методов». Это означает, что если функция перегружена, она содержит то же имя функции, пока оно переопределено.

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

Реализация перегрузки в C ++

 перегрузка класса {int a, b; public: int load (int x) {// первая загрузка () function a = x; вернуть; } int load (int x, int y) {// секунда load () function a = x; б = у; вернуть a * b; }}; int main () {перегрузка O1; O1.load (20); // первый вызов функции load () O1.load (20, 40); // второй вызов функции load ()} 

Здесь перегружена функция load () класса. Две перегруженные функции класса можно различить таким образом, что первая функция load () принимает только один целочисленный параметр, тогда как вторая функция load () принимает два целочисленных параметра. Когда объект перегрузки класса вызывает функцию load () с одним параметром, вызывается первая функция load (). Когда объект вызывает функцию load (), передавая два параметра, вызывается вторая функция load ().

Определение переопределения

Полиморфизм, достигнутый во время выполнения, называется «переопределением». Это достигается с помощью «наследования» и «виртуальных функций». Переопределяемой функции предшествует ключевое слово «virtual» в базовом классе и переопределение в производном классе без какого-либо ключевого слова.

Одна из самых важных вещей, которую следует помнить в случае переопределения, - то, что прототип переопределенной функции не должен изменяться, пока производный класс переопределяет его. Когда переопределенной функции дается вызов, C ++ определяет, какая версия функции вызывается, основываясь на «типе объекта, на который указывает указатель», с помощью которого выполняется вызов функции.

Реализация переопределения в C ++

 class base {public: virtual void funct () {// виртуальная функция базового класса cout << "Это funct () базового класса"; }}; класс производный1: публичная база {public: void funct () {// виртуальная функция базового класса, переопределенная в производном классе cout << "Это функция дочернего класса производного1 ()"; }}; класс производный2: публичная база {public: void funct () {// виртуальная функция базового класса, переопределенная в производном классе cout  функц (); // вызов функции Funct () для производного класса. * Р = & d2; п-> функц (); // вызов функции Funct () класса производной 2 вернуть 0; } 

Здесь есть один базовый класс, который публично наследуется двумя производными классами. Виртуальная функция определяется в базовом классе с ключевым словом «virtual», и она переопределяется обоими производными классами без ключевого слова. В main () базовый класс создает переменную-указатель «p» и объект «b»; Производный класс создает объект d1, а производный класс создает объект d2.

Теперь изначально адрес объекта базового класса «b» присваивается указателю базового класса «p». 'p' вызывает функцию funct (), поэтому вызывается функция базового класса. Затем адрес объекта класса производного «d1» присваивается указателю «p», опять же он вызывает funct (); здесь выполняется функция funct () класса производного1. Наконец, указатель 'p' присваивается объекту класса производного 2. Затем 'p' вызывает функцию funct (), которая выполняет функцию func () класса производного 2.

Если бы производный / производный2 класс не переопределил функцию funct (), тогда функция funct () базового класса была бы вызвана, поскольку виртуальная функция является «иерархической».

Ключевые различия между перегрузкой и переопределением

  1. Прототип перегруженной функции отличается из-за типа и количества параметров, которые передаются перегруженной функции. С другой стороны, прототип переопределенной функции не изменяется, поскольку переопределенная функция выполняет другое действие для другого класса, к которому она принадлежит, но с тем же типом и номером параметра.
  2. Имя перегруженной функции не предшествует ни одному ключевому слову, тогда как имя переопределенной функции предшествует ключевому слову «Виртуальный» только в базовом классе.
  3. Какая перегруженная функция вызывается, зависит от типа или количества параметров, передаваемых в функцию. Переопределенная функция того, какой класс вызывается, зависит от того, какой адрес объекта класса назначен указателю, который вызвал функцию.
  4. Какая перегруженная функция должна быть вызвана, решается во время компиляции. Какая переопределенная функция, которую нужно вызвать, определяется во время выполнения.
  5. Конструкторы могут быть перегружены, но не могут быть переопределены.
  6. Деструкторы не могут быть перегружены, но они могут быть переопределены.
  7. Перегрузка обеспечивает раннее связывание, поскольку перегруженная функция разрешается во время компиляции. Переопределение достигает позднего связывания, так как переопределенная функция, которая будет вызываться, разрешается во время выполнения.

сходства

  1. Оба применяются к функциям-членам класса.
  2. Полиморфизм является основной концепцией обоих.
  3. Имя функции остается неизменным, пока мы применяем перегрузку и переопределение функций.

Заключение

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

Top