Polymorphism in C++

By: Rajesh P.S.

Polymorphism in C++ is a fundamental concept in object-oriented programming that enables objects of different classes to be treated as objects of a common base class. It allows for the same interface, typically in the form of functions or methods, to be used with objects of various derived classes, enabling dynamic method dispatch based on the actual object type at runtime. Polymorphism promotes code reusability, extensibility, and flexibility, allowing developers to write generic code that can work with different types of objects while maintaining a consistent and intuitive interface.

Real Life Example Of Polymorphism

Real-life instance of polymorphism in the operation of different vehicles will be service as an illustration. As for the start function "start". This method is utilized in polymorphism to work with different vehicles like cars, bicycles or motorcycles, each having a unique way of starting its engines - turning the key, spinning a pedal or engaging a starter lever. However, the universal nature of the start button on any car is something that they all have in common as it enables the user to hit and start the car without knowing the specific mechanics of each car. This reality analogy defines polymorphism by delivering the same interface for the lot of objects having different kinds of implementation.

Types of Polymorphism

Continue Reading...

Polymorphism can be categorized into two main types: compile-time polymorphism (also known as static polymorphism) and runtime polymorphism (also known as dynamic polymorphism). Here are the types of polymorphism within these categories:

Compile-Time Polymorphism (Static Polymorphism)

Compile-time polymorphism, often referred to as static polymorphism, is a type of polymorphism in C++ where the method to be executed is determined at compile time based on the number and types of arguments passed to a function or on the object's reference or pointer type. Function overloading and operator overloading are common examples of compile-time polymorphism. In function overloading, multiple functions can have the same name but different parameter lists, and the appropriate function to call is resolved during compilation based on the arguments provided. This allows for flexible and type-safe behavior at compile time, with the selection of the appropriate function occurring before the program is executed.

Function Overloading

Function overloading allows you to define multiple functions in the same scope with the same name but different parameter lists. The appropriate function to call is determined at compile time based on the number and types of arguments provided, providing a way to achieve polymorphic behavior.

#include <iostream> class Vehicle { public: int maxSpeed(int wheels) { if (wheels == 2) { return 30; // Max speed for bicycles } else { return 180; // Max speed for cars } } int maxSpeed(int wheels, int enginePower) { if (wheels == 4 && enginePower >= 150) { return 250; // Max speed for high-performance cars } else { return maxSpeed(wheels); // Call the previous maxSpeed function for other cases } } }; int main() { Vehicle vehicle; int carSpeed = vehicle.maxSpeed(4, 200); // High-performance car int bikeSpeed = vehicle.maxSpeed(2); // Bicycle std::cout << "Max speed of the car: " << carSpeed << " km/h" << std::endl; std::cout << "Max speed of the bicycle: " << bikeSpeed << " km/h" << std::endl; return 0; }

In this example, the Vehicle class contains two overloaded maxSpeed functions. The first function calculates the maximum speed based on the number of wheels, and the second function considers the engine power in addition to the wheel count. When you call these functions with different arguments, the appropriate overloaded function is selected at compile time. For instance, vehicle.maxSpeed(4, 200) calls the high-performance car version, while vehicle.maxSpeed(2) calls the bicycle version. This demonstrates compile-time polymorphism through function overloading, where the selection of the appropriate function is determined at compile time based on the function's parameter list and arguments provided.

Operator Overloading

C++ allows you to define custom behaviors for operators like +, -, *, /, etc., when applied to user-defined classes or types.

#include <iostream> class Vehicle { private: int speed; public: Vehicle(int initialSpeed) : speed(initialSpeed) {} // Overload the + operator to simulate adding speeds of two vehicles Vehicle operator+(const Vehicle& other) const { return Vehicle(speed + other.speed); } int getSpeed() const { return speed; } }; int main() { Vehicle car(120); // Speed of a car Vehicle bike(25); // Speed of a bicycle // Combine the speeds using operator overloading Vehicle combined = car + bike; std::cout << "Car Speed: " << car.getSpeed() << " km/h" << std::endl; std::cout << "Bicycle Speed: " << bike.getSpeed() << " km/h" << std::endl; std::cout << "Combined Speed: " << combined.getSpeed() << " km/h" << std::endl; return 0; }

In this example, we create a Vehicle class and overload the + operator to simulate adding the speeds of two vehicles. The operator+ function takes another Vehicle object as an argument and returns a new Vehicle with the combined speed. When we use the + operator on instances of the Vehicle class (e.g., car + bike), the overloaded operator is invoked, and the result is a new Vehicle object representing the combined speed. This demonstrates operator overloading, a form of compile-time polymorphism, where operators are defined to work with user-defined types in a way that makes sense for those types.

Runtime Polymorphism (Dynamic Polymorphism)

Function Overriding with Virtual Functions: Inheritance and virtual functions allow derived classes to provide their implementations for functions with the same name as those in the base class. The specific implementation to call is determined at runtime, based on the object's actual type, allowing for dynamic method dispatch. This is achieved using the 'virtual' keyword in the base class.

#include <iostream> class Vehicle { public: virtual void describe() { std::cout << "This is a generic vehicle." << std::endl; } }; class Car : public Vehicle { public: void describe() override { std::cout << "This is a car." << std::endl; } }; class Bicycle : public Vehicle { public: void describe() override { std::cout << "This is a bicycle." << std::endl; } }; int main() { Vehicle* vehicle1 = new Car(); Vehicle* vehicle2 = new Bicycle(); vehicle1->describe(); // Calls the describe() method of the Car class vehicle2->describe(); // Calls the describe() method of the Bicycle class delete vehicle1; delete vehicle2; return 0; }

In this example, we define a base class Vehicle with a virtual function describe(). We then create two derived classes, Car and Bicycle, both of which override the describe() function with their specific implementations.

In the main() function, we create two pointers to the base class Vehicle and assign objects of the derived classes to them. When we call describe() through these pointers, the appropriate overridden function is invoked based on the actual object type at runtime. This demonstrates runtime polymorphism, where the decision of which function to call is made during program execution, allowing dynamic method dispatch based on the actual object type. In this way, you can achieve polymorphic behavior with different types of vehicles.

These types of polymorphism enable developers to write flexible and reusable code by allowing the same interface to work with different objects or classes, each with its own specific implementation.

Conclusion

Polymorphism in C++ is a fundamental object-oriented programming concept that enables objects of different classes to be treated as objects of a common base class. It allows for the same interface, typically in the form of functions or methods, to be used with objects of various derived classes, facilitating dynamic method dispatch based on the actual object type at runtime. Polymorphism enhances code flexibility, reusability, and extensibility, enabling developers to write more generic and adaptable code while maintaining a consistent and intuitive interface.

Next > C++ Virtual Functions

Related Topics

More Related Topics.....