Course Content

C++ OOP

1. Fundamentals of OOP in C++

Introduction to Object-Oriented Programming in C++Why use Object-Oriented Programming?Class Creation Syntax Attributes of the Class Methods of the Class Static Members of The Class The This Keyword Classes and Objects Overview

2. Constructors and Destructors

What is a Constructor of the Class Constructor and Attributes Constructor Initialization List Initialization List Practice Constructor Delegation Constructor Delegation Practice What is a Destructor of the Class Constructors and Destructors Practice

3. Encapsulation Overview

Introduction to Encapsulation Access Modifiers Keywords Access Modifiers Practice Accessor and Mutator Methods Segmentation and Aggregation The Friend Keyword

4. Inheritance Overview

Introduction to Inheritance Access Modifiers in Inheritance Mulptiple Inheritance Constructor and Destructor in Inheritance Diamond Inheritance The Final Keyword

5. Polymorphism Overview

Introduction to Polymorphism Virtual and Override Keywords Pure Virtual Method Operator Overloading

Introduction to Polymorphism

Definition

Polymorphism stands as a pivotal concept. Derived from Greek meaning "many shapes," it allows objects of different classes to be treated as an object of a common superclass. The most significant aspect is the ability of different entities to respond in their own way to the same message or method call.

Types of Polymorphism

There are two main types of polymorphism: compile-time (static) and runtime (dynamic). Understanding how and when to use each is crucial for writing flexible, efficient code.

Compile-time polymorphism: occurs through function or operator overloading, where the method to execute is determined at compile time.
Runtime polymorphism: uses virtual functions, allowing derived classes to override base class methods, with the correct method chosen at runtime.

Application and need for polymorphism

An excellent way to understand polymorphism is through a real-world analogy. Consider a graphical user interface with a button. This button can behave differently depending on the context—it might function as an upload button, a reset button, or a cancel button.

Each button executes a distinct action upon being clicked, but all of them are essentially serve as buttons. Look the theoretical implementation of this concept.

UploadButton.h

ResetButton.h

CancelButton.h


              1234
            
class UploadButton : public Button {
public:
    void onClick() { std::cout << "Upload" << std::endl; }  
};

Considering that all buttons share the same onClick() method with varying implementations, let's dive deeper. What if we need a function that accepts an object belonging to one of the button classes as a parameter?

main.cpp


              1234567891011
            
void user_clicked_upload_button(const UploadButton& btn) {
    btn.onClick();
}

void user_clicked_reset_button(const ResetButton& btn) {
    btn.onClick();
}

void user_clicked_cancel_button(const CancelButton& btn) {
    btn.onClick();
}

As you can see manually creating separate functions for each button can create complexity, especially during modifications, as each function must be edited individually if issues arise. Also, in the main function, additional checks will be necessary to determine which function to call. Polymorphism allows for easy resolution of these problems.

Everything was clear?

Thanks for your feedback!

Section 5. Chapter 1

Ask AI

Ask anything or try one of the suggested questions to begin our chat