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

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

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

Вывод:

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

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

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().

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

Перегрузка оператора

В разделе «Перегрузка операторов» мы определяем новое значение оператора 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. Определите две целочисленные переменные, real и over.
6. Используйте модификатор доступа 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. Вторая часть с1 будет добавлена ​​ко второй части с, то есть 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. Используйте модификатор public access, чтобы сделать функцию, которую мы собираемся создать, общедоступной. Он будет доступен за пределами этого класса.
5. Создайте общедоступную функцию с именем eat. { отмечает начало тела функции.
6. Вывести оператор, добавленный в функцию cout при вызове функции eat().
7. Конец тела функции eat().
8. Конец тела класса млекопитающих.
9. Создайте класс Cow, наследующий класс Mammal. Cow — это производный класс, а Mammal — базовый класс. { отмечает начало этого класса.
10. Используйте модификатор public access, чтобы пометить функцию, которую мы собираемся создать, как общедоступную. Он будет доступен из-за пределов этого класса.
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. Используйте модификатор доступа public, чтобы пометить член класса как общедоступный.
5. Создайте виртуальную функцию с именем show(). Это будет общественное мероприятие.
6. Текст для печати при вызове метода show(). endl — это ключевое слово C++, означающее конечную строку. Он перемещает курсор мыши на следующую строку.
7. Конец тела виртуальной функции show().
8. Конец тела класса ClassA.
9. Создание нового класса ClassB, наследующего класс ClassA. ClassA становится базовым классом, а ClassB становится производным классом.
10. Используйте модификатор доступа public, чтобы пометить член класса как общедоступный.
11. Переопределите виртуальную функцию show(), производную от базового класса.
12. Текст, выводимый на консоль при вызове функции show(), определенной в производном классе.
13. Конец тела функции show().
14. Конец тела производного класса ClassB.
15. Вызовите функцию main(). Логика программы должна быть добавлена ​​в ее тело.
16. Создайте переменную-указатель с именем a. Он указывает на класс с именем ClassA.
17. Создайте экземпляр класса ClassB. Экземпляру дается имя b.
18. Назначьте значения, хранящиеся по адресу b, в переменной a.
19. Вызвать функцию show(), определенную в производном классе. Реализовано позднее связывание.
20. Конец тела функции main().

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

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

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

Обзор:

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