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

Вывод:

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

Пояснение к коду:

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

Вывод:

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

Пояснение к коду:

1. Включите заголовочный файл iostream в нашу программу, чтобы использовать его функции.
2. Включите пространство имен std в нашу программу, чтобы использовать его классы, не вызывая его.
3. Создайте класс с именем ComplexNum. { отмечает начало тела класса.
4. Используйте модификатор доступа Private, чтобы пометить переменные как частные, то есть доступ к ним возможен только внутри класса.
5. Определите две целочисленные переменные: вещественную и более.
6. Используйте модификатор публичного доступа, чтобы пометить конструктор как общедоступный, что означает, что он будет доступен даже снаружи. класс.
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;

}

Вывод:

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

Пояснение к коду:

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

Вывод:

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

Пояснение к коду:

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 обеспечивается гибкость решения проблем, поскольку все известно во время компиляции.	Для решения сложных задач обеспечивается большая гибкость, поскольку методы обнаруживаются во время выполнения.

Резюме

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