C++ Полиморфизм с примером

⚡ Умное резюме

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

  • 🔷 Определение: Полиморфизм означает «множество форм», позволяющее одной и той же функции вести себя по-разному в зависимости от вызывающего объекта.
  • 🧭 Два типа: C++ обеспечивает полиморфизм на этапе компиляции (статический) и полиморфизм на этапе выполнения (динамический).
  • 🧩 Время компиляции: Перегрузка функций и перегрузка операторов позволяют выбрать правильную функцию во время компиляции.
  • 🔁 Время работы: Переопределение функций и виртуальные функции разрешают вызов во время выполнения программы.
  • ⚙️ Виртуальные функции: Ключевое слово virtual в базовом классе позволяет осуществлять позднее связывание через указатель на базовый класс.
  • 🤖 Помощь ИИ: GitHub Copilot и аналогичные сервисы создают генераторы перегруженных, переопределенных и виртуальных функций на основе короткого комментария.

C++ Полиморфизм

Что такое полиморфизм C++?

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

Например, предположим, что у нас есть функция makeSound(). Когда кошка вызывает эту функцию, она издает звук мяуканья. Когда корова вызывает ту же функцию, она издает звук мычания.

Полиморфизм в C++ пример makeSound

Хотя у нас есть одна функция, в разных обстоятельствах она ведет себя по-разному. Функция имеет множество форм; следовательно, мы достигли полиморфизма.

Исходя из основной идеи, C++ Это поведение подразделяется на две отдельные категории.

Типы полиморфизма

C++ поддерживает два типа полиморфизма:

  • Полиморфизм времени компиляции и
  • Полиморфизм времени выполнения.

Типы полиморфизма в C++

Первая категория обрабатывает каждый вызов функции до запуска программы.

Полиморфизм времени компиляции

Вы вызываете перегруженные функции, сопоставляя количество и тип аргументов. Информация присутствует во время компиляции. Это означает, C++ компилятор выберет правильную функцию во время компиляции.

Полиморфизм времени компиляции достигается за счет перегрузки функций и перегрузки операторов.

Перегрузка функций

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

Пример 1

#include <iostream> 
using namespace std;

void test(int i) {
	cout << " The int is " << i << endl;
}
void test(double  f) {
	cout << " The float is " << f << endl;
}
void test(char const *ch) {
	cout << " The char* is " << ch << endl;
}

int main() {
	test(5);
	test(5.5);
	test("five");
	return 0;
}

Выход:

C++ Пример перегрузки функций. Пример 1. Вывод.

Вот скриншот кода:

C++ Перегрузка функций. Пример кода 1.

Code Объяснение:

  1. Включите заголовочный файл iostream в наш код. Мы сможем использовать его функции.
  2. Включите пространство имен std в наш код. Мы сможем использовать его классы, не вызывая его.
  3. Создайте функцию с именем test, которая принимает целочисленный параметр i. { отмечает начало тела функционального теста.
  4. Оператор, который будет выполнен, если вызывается/вызывается указанный выше функциональный тест.
  5. Конец тела приведенного выше функционального теста.
  6. Создайте функцию с именем test, которая принимает параметр f с плавающей запятой. { отмечает начало тела функционального теста.
  7. Оператор, который будет выполнен, если вызывается/вызывается указанный выше функциональный тест.
  8. Конец тела приведенного выше функционального теста.
  9. Создайте функцию с именем test, которая принимает символьный параметр ch. { отмечает начало тела функционального теста.
  10. Оператор, который будет выполнен, если вызывается/вызывается указанный выше функциональный тест.
  11. Конец тела приведенного выше функционального теста.
  12. Вызовите функцию main(). { отмечает начало тела функции.
  13. Вызовите функцию test и передайте ей 5 в качестве значения аргумента. Это вызывает тестовую функцию, которая принимает целочисленный аргумент, то есть первую тестовую функцию.
  14. Вызовите функцию test и передайте ей 5.5 в качестве значения аргумента. Это вызовет тестовую функцию, которая принимает аргумент с плавающей запятой, то есть вторую тестовую функцию.
  15. Вызовите функцию test и передайте ей пять в качестве значения аргумента. Это вызовет тестовую функцию, которая принимает символьный аргумент, то есть третью тестовую функцию.
  16. Программа должна вернуть значение, если она работает успешно.
  17. Конец тела функции main().

У нас есть три функции с одинаковым именем, но с разными типами аргументов. Мы добились полиморфизма.

Operaперегрузка tor

In Operator Перегружая, мы определяем новое значение для C++ операторЭто также меняет принцип работы оператора. Например, мы можем определить оператор + для конкатенации двух строк. Мы знаем его как оператор сложения для сложения числовых значений. После нашего определения, если он помещен между целыми числами, он их сложит. Если он помещен между строками, он их конкатенирует.

Пример 2

#include<iostream> 
using namespace std;

class ComplexNum {
private:
	int real, over;
public:
	ComplexNum(int rl = 0, int ov = 0) {
		real = rl;   
		over = ov; 
	}

	ComplexNum operator + (ComplexNum const &obj) {
		ComplexNum result;
		result.real = real + obj.real;
		result.over = over + obj.over;
		return result;
	}
	void print() { 
		cout << real << " + i" << over << endl; 
	}
};
int main()
{
	ComplexNum c1(10, 2), c2(3, 7);
	ComplexNum c3 = c1+c2;
	c3.print();
}

Выход:

C++ Пример 2: перегрузка оператора, вывод.

Вот скриншот кода:

C++ Пример кода 2: перегрузка операторов

C++ Пример 2: перегрузка оператора.

Code Объяснение:

  1. Включите заголовочный файл iostream в нашу программу, чтобы использовать его функции.
  2. Включите пространство имен std в нашу программу, чтобы использовать его классы, не вызывая его.
  3. Создайте класс с именем ComplexNum. { отмечает начало тела класса.
  4. Используйте модификатор доступа Private, чтобы пометить переменные как частные, то есть доступ к ним возможен только внутри класса.
  5. Определите две целочисленные переменные: вещественную и более.
  6. Используйте модификатор доступа public, чтобы пометить конструктор как public, что означает, что он будет доступен даже извне класса.
  7. Создайте конструктор класса и инициализируйте переменные.
  8. Инициализируйте значение переменной real.
  9. Инициализируйте значение переменной заново.
  10. Конец тела конструктора.
  11. Нам нужно переопределить значение оператора +.
  12. Создайте результат типа данных ComplexNum.
  13. Используйте оператор + с комплексными числами. Эта строка добавит действительную часть числа к действительной части другого числа.
  14. Используйте оператор + с комплексными числами. Эта строка добавит мнимую часть числа к мнимой части другого числа.
  15. Программа вернет значение переменной result при успешном выполнении.
  16. Конец определения нового значения оператора +, то есть перегрузки.
  17. Вызовите метод print().
  18. Выведите новое комплексное число после сложения на консоли.
  19. Конец тела функции print().
  20. Конец тела класса ComplexNum.
  21. Вызовите функцию main().
  22. Передайте значения как реальных, так и сложных частей, которые нужно добавить. Первая часть c1 будет добавлена ​​к первой части c2, то есть 10+3. Вторая часть c1 будет добавлена ​​ко второй части c, то есть 2+7.
  23. Выполните операцию, используя перегруженный оператор + и сохранив результат в переменной c3.
  24. Выведите значение переменной c3 на консоль.
  25. Конец тела функции main().

В то время как полиморфизм на этапе компиляции принимает решение на ранней стадии, вторая категория откладывает выбор до момента выполнения.

Полиморфизм времени выполнения

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

Переопределение функции

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

Например:

#include <iostream>
using namespace std;
class Mammal {

public:
	void eat() {

		cout << "Mammals eat...";
	}

};

class Cow: public Mammal {

public:
	void eat() {

		cout << "Cows eat grass...";
	}
};
int main(void) {

	Cow c = Cow();

	c.eat();

	return 0;

}

Выход:

C++ функция переопределяет вывод

Вот скриншот кода:

C++ код переопределения функции

Code Объяснение:

  1. Импортируйте заголовочный файл iostream в нашу программу, чтобы использовать ее функции.
  2. Включите пространство имен std в нашу программу, чтобы использовать его классы, не вызывая его.
  3. Создайте класс с именем Mammal. { отмечает начало тела класса.
  4. Используйте модификатор публичного доступа, чтобы сделать функцию, которую мы собираемся создать, общедоступной. Он будет доступен снаружи этого класса.
  5. Создайте публичную функцию с именем eat. { отмечает начало тела функции.
  6. Выведите оператор, добавленный в функцию cout при вызове функции eat().
  7. Конец тела функции eat().
  8. Конец тела класса Mammal.
  9. Создайте класс с именем Cow, который наследует класс Mammal. Cow — производный класс, а Mammal — базовый класс. { отмечает начало этого класса.
  10. Используйте модификатор публичного доступа, чтобы пометить функцию, которую мы собираемся создать, как общедоступную. Он будет доступен снаружи этого класса.
  11. Переопределить функцию eat(), определенную в базовом классе. { отмечает начало тела функции.
  12. Оператор, выводимый на консоль при вызове этой функции.
  13. Конец тела функции eat().
  14. Конец тела класса Cow.
  15. Вызовите функцию main(). { отмечает начало тела этой функции.
  16. Создайте экземпляр класса Cow и присвойте ему имя c.
  17. Вызовите функцию eat(), определенную в классе Cow.
  18. Программа должна вернуть значение после успешного завершения.
  19. Конец функции main().

C++ Виртуальная функция

Виртуальная функция — это еще один способ реализации полиморфизма во время выполнения в C++. Это специальная функция, определенная в базовом классе и переопределенная в производном классе. Чтобы объявить виртуальную функцию, вы должны использовать ключевое слово virtual. Ключевое слово должно предшествовать объявлению функции в базовом классе.

Если класс виртуальной функции унаследован, виртуальный класс переопределяет виртуальную функцию в соответствии со своими потребностями. Например:

#include <iostream>  
using namespace std;
class ClassA {
		public:
		virtual void show() {
			cout << "The show() function in base class invoked..." << endl;
		}
	};
	class ClassB :public ClassA {
	public:
		void show() 	{
			cout << "The show() function in derived class invoked...";
		}
	};
	int main() {
		ClassA* a;   
		ClassB b;
		a = &b;
		a->show();      
	}

Выход:

C++ вывод виртуальной функции

Вот скриншот кода:

C++ код виртуальной функции

Code Объяснение:

  1. Включите заголовочный файл iostream в код, чтобы использовать его функции.
  2. Включите пространство имен std в наш код, чтобы использовать его классы, не вызывая его.
  3. Создайте класс с именем ClassA.
  4. Используйте модификатор публичного доступа, чтобы пометить член класса как общедоступный.
  5. Создайте виртуальную функцию с именем show(). Это будет общественная функция.
  6. Текст для печати при вызове show(). Конец - это C++ ключевое слово, которое означает конечную строку. Он перемещает курсор мыши на следующую строку.
  7. Конец тела виртуальной функции show().
  8. Конец тела класса ClassA.
  9. Создание нового класса с именем ClassB, который наследует класс ClassA. ClassA становится базовым классом, а ClassB — производным классом.
  10. Используйте модификатор публичного доступа, чтобы пометить член класса как общедоступный.
  11. Переопределите виртуальную функцию show(), производную от базового класса.
  12. Текст, выводимый на консоль при вызове функции show(), определенной в производном классе.
  13. Конец тела функции show().
  14. Конец тела производного класса ClassB.
  15. Вызовите функцию main(). Логика программы должна быть добавлена ​​в ее тело.
  16. Создайте переменную-указатель с именем a. Он указывает на класс с именем ClassA.
  17. Создайте экземпляр класса с именем ClassB. Экземпляру присваивается имя b.
  18. Присвойте значения, хранящиеся по адресу b, в переменной a.
  19. Вызовите функцию show(), определенную в производном классе. Реализовано позднее связывание.
  20. Конец тела функции main().

После рассмотрения обоих механизмов, в таблице ниже приведено их сравнительное сопоставление.

Полиморфизм времени компиляции против. Полиморфизм во время выполнения

Вот основные различия между ними:

Полиморфизм во время компиляции Полиморфизм во время выполнения
Это явление также называют ранним связыванием или статическим полиморфизмом. Это явление также называют поздним/динамическим связыванием или динамическим полиморфизмом.
Метод вызывается/вызывается во время компиляции. Метод вызывается/вызывается во время выполнения
Реализовано через перегрузку функций и перегрузку операторов. Реализовано через переопределение метода и виртуальные функции.
Пример перегрузки метода. Многие методы могут иметь похожие имена, но разное количество или типы аргументов. Пример переопределения метода. Многие методы могут иметь похожее имя и один и тот же прототип.
Более быстрое выполнение, поскольку обнаружение метода происходит во время компиляции. Более медленное выполнение, поскольку обнаружение методов происходит во время выполнения программы.
Less обеспечивается гибкость решения проблем, поскольку все известно во время компиляции. Для решения сложных задач обеспечивается большая гибкость, поскольку методы обнаруживаются во время выполнения.

Часто задаваемые вопросы (FAQ)

Перегрузка определяет несколько функций с одинаковым именем, но разными параметрами, которые разрешаются во время компиляции без наследования. Переопределение переопределяет унаследованную функцию базового класса с той же сигнатурой в производном классе, и она разрешается во время выполнения, когда функция объявляется виртуальной.

Чисто виртуальная функция объявляется с параметром = 0 и не имеет тела в базовом классе. Любой класс, содержащий такую ​​функцию, становится абстракцией.tracКласс t, который нельзя создать напрямую, и который вынуждает производные классы предоставлять собственную реализацию.

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

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

При удалении производного объекта через указатель базового класса только виртуальный деструктор гарантирует выполнение деструктора производного класса. Без него очистка будет неполной и приведет к утечкам памяти. Объявление деструктора базового класса виртуальным делает процесс уничтожения полиморфным.

Полиморфизм позволяет одному интерфейсу обрабатывать множество типов объектов, уменьшая дублирование кода и упрощая его сопровождение. Он поддерживает гибкие, расширяемые проекты, в которых новые производные классы подключаются без изменения существующего кода, и позволяет создавать мощные шаблоны на основе указателей и ссылок базового класса.

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

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

Подведем итог этой публикации следующим образом: