Introduction to OOPs using C++ SEM 2 Uint-2 Question Bank Solution

   FY.Bsc.Cs Sem-2 Based on Mumbai Unversity 

Introduction to OOPs using C++ (Uint-2) Question Bank Answer:-

1. What is a constructor and why is it needed?

A constructor in C++ is a special member function of a class that is automatically called when an object of the class is created. It has the same name as the class and is used to initialize the object's data members or perform any necessary setup. Constructors play a crucial role in object initialization and are called implicitly when an object is instantiated.

Key points about constructors:

1. Syntax:

• A constructor has the same name as the class.
• It doesn't have a return type, not even void.
• It may have parameters, allowing for different ways of initializing objects.
• class MyClass { public: // Default constructor MyClass() { // Initialization code here } // Parameterized constructor MyClass(int parameter) { // Initialization code with parameter } };

  Default Constructor:

  • If a class doesn't have any constructor defined, C++ provides a default constructor automatically. It initializes the object with default values or leaves the members uninitialized.
  • class MyClass { public: // Default constructor provided by C++ };

    1. Purpose of Constructors:

       • Initialization: Constructors initialize the object's data members, ensuring that the object starts in a valid state.
       • Memory Allocation: Constructors can allocate dynamic memory if necessary.
       • Configuration: They can perform any necessary setup or configuration.

    2. Why Constructors are Needed:

       • Default Initialization: Constructors ensure that objects are initialized properly, avoiding issues with uninitialized data.
       • Custom Initialization: Constructors allow for custom initialization based on specific parameters or conditions.
       • Object Creation: Constructors are automatically invoked when objects are created, simplifying the object instantiation process.
  2.Explain accessor and mutator methods?
• 
  
2. 
   
3. 
   

4. Accessor and mutator methods are two types of member functions within a class that are used to control access to the private data members. They are often referred to as getters and setters, respectively.

   1. Accessor Methods (Getters):

   • Accessor methods are used to retrieve the values of private data members from a class.
   • They provide read-only access to the internal state of an object.
   • Accessor methods are typically declared as const to indicate that they do not modify the object.
   2. class MyClass { private: int myPrivateVariable; public: // Accessor method (getter) int getMyPrivateVariable() const { return myPrivateVariable; } };

   Example usage:

   MyClass obj;
   
   

5. int value = obj.getMyPrivateVariable();
6. 
   

7. Mutator Methods (Setters):

   • Mutator methods are used to modify the values of private data members from a class.
   • They provide a way to update the internal state of an object.
   • Mutator methods may include validation logic to ensure that the changes made are valid.
   class MyClass { private: int myPrivateVariable; public: // Mutator method (setter) void setMyPrivateVariable(int newValue) { // Additional validation logic can be added here myPrivateVariable = newValue; }Example usage:
   
   
8. MyClass obj; obj.setMyPrivateVariable(42);
9. 
   
10. Accessor and mutator methods help enforce encapsulation by controlling access to the internal state of a class. Accessors allow reading private data, while mutators allow modifying it in a controlled manner. This promotes data integrity and helps maintain a class's internal consistency.

3.What is a default and parameterized constructor?

In C++, constructors can be categorized into two main types: default constructor and parameterized constructor.

1. Default Constructor:

• A default constructor is a special constructor that doesn't take any parameters.
• If a class doesn't explicitly define any constructor, C++ provides a default constructor automatically.
• The default constructor initializes the object's data members, typically to default values (zero, null, etc.).
2. class MyClass { public: // Default constructor MyClass() { // Initialization code (if any) } };
3. Example usage:
4. MyClass obj; // Default constructor is called

Parameterized Constructor:

• A parameterized constructor is a constructor that accepts parameters, allowing for the initialization of an object with specific values.
• It enables customization during object creation by providing values for the object's data members.
• class MyClass { private: int myPrivateVariable; public: // Parameterized constructor MyClass(int initialValue) { myPrivateVariable = initialValue; } };
• Example usage:
• MyClass obj(42); // Parameterized constructor is called with an initial value

• 1. Multiple parameters can also be used in a parameterized constructor to initialize different data members with distinct values.

  Constructors play a crucial role in setting up the initial state of objects. The default constructor is used when no specific initialization is provided, while the parameterized constructor allows for customized initialization based on user-specified values.

4.Explain copy constructor with example?

A copy constructor in C++ is a special constructor used to create a new object as a copy of an existing object. It is called when an object is passed by value, returned by value, or explicitly when a new object is constructed as a copy of another object. The copy constructor is typically defined with a single parameter of the same type as the class.

Here's an example of a copy constructor:

#include <iostream> class MyClass { private: int myData; public: // Parameterized constructor MyClass(int data) : myData(data) { std::cout << "Parameterized constructor called." << std::endl; } // Copy constructor MyClass(const MyClass &other) : myData(other.myData) { std::cout << "Copy constructor called." << std::endl; } // Member function to display data void displayData() const { std::cout << "Data: " << myData << std::endl; } }; int main() { // Creating an object using the parameterized constructor MyClass originalObject(42); originalObject.displayData(); // Creating a new object using the copy constructor MyClass copiedObject = originalObject; copiedObject.displayData(); return 0; }

In this example:

• The MyClass has a parameterized constructor that initializes the myData member.
• The copy constructor MyClass(const MyClass &other) is defined to create a new object by copying the data from another object of the same type.
• In the main function, an object originalObject is created using the parameterized constructor, and its data is displayed.
• Another object copiedObject is created using the copy constructor by assigning originalObject. The copy constructor is called, and the data is displayed.

Output:

Parameterized constructor called. Data: 42 Copy constructor called. Data: 42

The copy constructor is called when a new object is created as a copy of an existing object, allowing for the creation of identical objects with the same data.

5. Explain static data members and its properties?

In C++, a static data member is a member of a class that is shared among all instances of that class. Unlike regular (non-static) data members, static data members are associated with the class itself rather than individual objects of the class. They are declared with the keyword static and have some unique properties:

1. Declaration and Initialization:

• A static data member is declared inside the class definition but needs to be defined outside the class to allocate storage space. The definition includes the data type and the actual variable.
2. class MyClass { public: static int staticDataMember; }; // Definition and initialization of the static data member int MyClass::staticDataMember = 0;

3. Shared Among All Objects:

   • All instances of the class share the same static data member. Any modification to the static data member affects all objects.
   • MyClass obj1; MyClass obj2; obj1.staticDataMember = 42; std::cout << obj2.staticDataMember << std::endl; // Outputs 42

   Accessing Static Data Member:

   • Static data members can be accessed using the class name and the scope resolution operator ::.
   • MyClass::staticDataMember = 100;

   Initialization Outside the Class:

   • Static data members are initialized outside the class. If not explicitly initialized, they are initialized to zero by default.
   • int MyClass::staticDataMember = 10;

   • Memory Allocation:

     • Static data members are stored in the data segment of the program, and their memory is allocated only once for the entire class, regardless of how many objects are created.
     • class MyClass { public: static int staticDataMember; }; int main() { std::cout << sizeof(MyClass::staticDataMember) << std::endl; // Outputs the size of int return 0; }
     Static data members provide a way to share data among all instances of a class and are often used for properties that are common to the entire class rather than specific to individual objects. They have a single instance shared by all objects, leading to more efficient memory usage when the same value is shared among many instances of the class.

   6.

   What is an array of objects and give an example?

An array of objects in C++ is a collection of objects of the same class type stored in a contiguous block of memory. It allows you to create multiple instances of a class and access them using array indexing. This is useful when you need to manage and manipulate a group of similar objects.

Here's an example of an array of objects:

#include <iostream> class Student { public: std::string name; int age; // Parameterized constructor Student(std::string studentName, int studentAge) : name(studentName), age(studentAge) {} }; int main() { const int numberOfStudents = 3; // Array of objects Student students[numberOfStudents] = { {"Alice", 20}, {"Bob", 22}, {"Charlie", 21} }; // Accessing and displaying information about each student for (int i = 0; i < numberOfStudents; ++i) { std::cout << "Student " << i + 1 << ": Name - " << students[i].name << ", Age - " << students[i].age << std::endl; } return 0; }

In this example:

• The Student class has member variables name and age along with a parameterized constructor for initialization.
• An array of Student objects named students is created with three instances, each initialized with a name and age.
• A loop is used to iterate through the array, and information about each student is displayed.

Output:

Student 1: Name - Alice, Age - 20 Student 2: Name - Bob, Age - 22 Student 3: Name - Charlie, Age - 21

Arrays of objects are useful when you want to manage a group of similar entities and perform operations on them collectively. They provide a convenient way to organize and manipulate data in a structured manner.

7. What is polymorphism and what are different types?

Polymorphism in C++ refers to the ability of objects to take on multiple forms. It allows objects of different classes to be treated as objects of a common base class. Polymorphism is achieved through two main mechanisms: compile-time (or static) polymorphism and runtime (or dynamic) polymorphism.

1. Compile-time Polymorphism (Function Overloading):

• Function overloading is a form of compile-time polymorphism where multiple functions in the same scope have the same name but different parameters.
• The appropriate function is selected during compile-time based on the number and types of arguments.
• #include <iostream> class PrintData { public: // Function overloading for different data types void print(int data) { std::cout << "Printing integer: " << data << std::endl; } void print(double data) { std::cout << "Printing double: " << data << std::endl; } }; int main() { PrintData printer; printer.print(5); // Calls print(int) printer.print(3.14); // Calls print(double) return 0; }

• Runtime Polymorphism (Virtual Functions and Inheritance):

  • Runtime polymorphism is achieved through virtual functions and inheritance.
  • A base class can have virtual functions, and derived classes can override these functions. The correct function is determined at runtime based on the actual type of the object.
  • It allows for more flexible and extensible code.
  • #include <iostream> // Base class with a virtual function class Shape { public: virtual void draw() const { std::cout << "Drawing a shape" << std::endl; } }; // Derived class overriding the virtual function class Circle : public Shape { public: void draw() const override { std::cout << "Drawing a circle" << std::endl; } }; int main() { Shape* shapePtr; Shape shape; Circle circle; // Using base class pointer to achieve polymorphism shapePtr = &shape; shapePtr->draw(); // Calls draw() of the base class shapePtr = &circle; shapePtr->draw(); // Calls draw() of the derived class return 0; }

  1. In this example, the Shape class has a virtual function draw(), and the Circle class overrides this function. The base class pointer shapePtr is used to achieve polymorphism by pointing to objects of both base and derived classes.

  Polymorphism enhances code reusability and flexibility by allowing objects to be treated in a more generalized way. It is a fundamental concept in object-oriented programming.

8. Explain the concept of Function overloading with an example.

Function overloading is a form of compile-time polymorphism in C++ where multiple functions in the same scope have the same name but different parameter lists. The appropriate function to call is determined by the number and types of arguments during compile-time. Here's an example to illustrate function overloading:

#include <iostream> class Calculator { public: // Function to add two integers int add(int a, int b) { return a + b; } // Function to add two doubles double add(double a, double b) { return a + b; } // Function to concatenate two strings std::string add(const std::string& str1, const std::string& str2) { return str1 + str2; } }; int main() { Calculator calculator; // Function overloading based on different parameter types int result1 = calculator.add(5, 7); double result2 = calculator.add(3.14, 2.5); std::string result3 = calculator.add("Hello, ", "World!"); // Displaying the results std::cout << "Result 1: " << result1 << std::endl; std::cout << "Result 2: " << result2 << std::endl; std::cout << "Result 3: " << result3 << std::endl; return 0; }

In this example:

• The Calculator class has three overloaded add functions.
• The first add function takes two integers, the second takes two doubles, and the third takes two strings.
• The functions have the same name (add) but different parameter lists.
• In the main function, the appropriate add function is called based on the arguments provided.

Output:

Result 1: 12 Result 2: 5.64 Result 3: Hello, World!

Function overloading allows for more flexibility and readability in code by providing different implementations of a function for different parameter types. It simplifies the usage of functions and promotes code reusability.

9.Explain operator overloading with an example.

Operator overloading in C++ allows you to define custom behaviors for operators when used with user-defined data types. This enables you to extend the functionality of operators beyond their conventional meanings. Here's an example of operator overloading using the + operator for a custom class:

#include <iostream> class Complex { private: double real; double imaginary; public: // Constructor to initialize complex numbers Complex(double r, double i) : real(r), imaginary(i) {} // Overloading the + operator for addition of complex numbers Complex operator+(const Complex& other) const { return Complex(real + other.real, imaginary + other.imaginary); } // Function to display complex numbers void display() const { std::cout << "Real: " << real << ", Imaginary: " << imaginary << std::endl; } }; int main() { // Creating two complex numbers Complex complex1(2.5, 3.0); Complex complex2(1.5, 2.0); // Using the overloaded + operator to add complex numbers Complex result = complex1 + complex2; // Displaying the result std::cout << "Result of addition:" << std::endl; result.display(); return 0; }

In this example:

• The Complex class represents complex numbers with real and imaginary parts.
• The + operator is overloaded for the Complex class by defining the operator+ member function. It takes another Complex object as a parameter and returns a new Complex object representing the sum of the two complex numbers.
• In the main function, two complex numbers (complex1 and complex2) are created, and their sum is obtained using the overloaded + operator.
• The result is then displayed using the display member function of the Complex class.

Output:

Result of addition: 
Real: 4, Imaginary: 5
Operator overloading allows you to use familiar operators with user-defined types, providing a more intuitive and expressive way to work with objects of your custom classe
10.Explain static function with an example.

A static member function in C++ is a function associated with the class rather than an instance of the class. It can be called using the class name, without creating an object of the class. Static member functions do not have access to the this pointer and cannot access non-static (instance) members directly. They are often used for operations that don't depend on the specific instance of the class.
Here's an example of a static member function:
#include <iostream>

class MathOperations {
public:
    // Static member function to add two numbers
    static int add(int a, int b) {
        return a + b;
    }

    // Static member function to multiply two numbers
    static int multiply(int a, int b) {
        return a * b;
    }
};

int main() {
    // Calling static member functions using the class name
    int sumResult = MathOperations::add(3, 4);
    int productResult = MathOperations::multiply(5, 6);

    // Displaying the results
    std::cout << "Sum: " << sumResult << std::endl;
    std::cout << "Product: " << productResult << std::endl;

    return 0;
}
In this example:
The MathOperations class has two static member functions: add and multiply.
Both functions can be called using the class name (MathOperations::add and MathOperations::multiply) without creating an object of the class.
The functions perform basic addition and multiplication operations, respectively.
Output:

Sum: 7
Product: 30
Static member functions are useful for operations that don't rely on specific instance data but are related to the class as a whole. They are called directly on the class rather than on instances, providing a way to organize and encapsulate functionality within a class.
11.Explain the concept of Association.
Association is a fundamental concept in object-oriented programming that represents a relationship between two or more classes. It describes how objects from different classes are related and interact with each other. In association, one class is associated with another class through a connection that signifies a more general "uses," "has," or "is part of" relationship.
Key points about association:
Types of Association:
Bi-directional Association: Both classes are aware of each other and can interact bidirectionally.
Uni-directional Association: Only one class is aware of the other, and the interaction is one-way.
Multiplicity:
Multiplicity defines the number of instances of one class related to the number of instances of another class.
It can be one-to-one, one-to-many, or many-to-many.
Role:
Role represents the name given to each end of the association. It provides a meaningful name to describe the nature of the relationship.
Example:
Consider the association between classes Student and Course. A student can enroll in multiple courses, and a course can have multiple students. This is a many-to-many association.
class Student {
public:
    // Class implementation
};

class Course {
public:
    // Class implementation
};

class Enrollment {
private:
    Student* student;
    Course* course;

public:
    Enrollment(Student* s, Course* c) : student(s), course(c) {}
};
In this example, the Enrollment class represents the association between Student and Course. It has pointers to instances of both classes, indicating that a student is enrolled in a particular course.
Association is a crucial concept for modeling relationships between classes, promoting a more modular and flexible design in object-oriented systems. It allows classes to work together, facilitating communication and collaboration in a meaningful way.

12.Explain the concept of Aggregation.
Aggregation is a specific form of association in object-oriented programming that represents a "whole-part" relationship between two classes. It implies that one class is a part of another class, but the two can exist independently. In aggregation, the "whole" class is responsible for managing the "part" class, and the part can be shared among multiple wholes.
Key points about aggregation:
Composition vs. Aggregation:
Aggregation is often confused with composition, but they have a key difference. In composition, the part cannot exist independently outside the whole (stronger relationship), while in aggregation, the part can exist independently (weaker relationship).
UML Notation:
In Unified Modeling Language (UML), aggregation is represented by a diamond-headed line connecting the classes, with a hollow diamond at the whole end.
Example:
Consider the relationship between a Department and Employee. A department can have multiple employees, but employees can exist independently or belong to different departments.
class Employee {
public:
    // Employee class implementation
};

class Department {
private:
    std::vector<Employee*> employees;

public:
    // Department class implementation
    void addEmployee(Employee* emp) {
        employees.push_back(emp);
    }
};
In this example, the Department class has an aggregation relationship with the Employee class. The Department class can have multiple employees, but each employee can exist independently or belong to different departments.
Aggregation is useful for modeling relationships where one class is composed of multiple instances of another class, and those instances can exist independently. It promotes modularity and reusability in the design of object-oriented systems.
13 Explain this pointer with an example.
In C++, the this pointer is a special pointer that points to the current object. It is a keyword and is implicitly available within the scope of member functions of a class. The this pointer is used to refer to the current instance of the class and is particularly useful in situations where there might be a need to differentiate between a local variable and a member variable with the same name.
Here's an example to illustrate the use of the this pointer:
#include <iostream>

class MyClass {
private:
    int data;

public:
    // Constructor to initialize the data member
    MyClass(int initData) : data(initData) {}

    // Member function to display data using the this pointer
    void displayData() const {
        // Using the this pointer to access the member variable
        std::cout << "Data: " << this->data << std::endl;
    }

    // Member function to compare the data of two objects
    bool isEqual(const MyClass& other) const {
        // Using the this pointer to access the member variable
        return this->data == other.data;
    }
};

int main() {
    // Creating two objects of MyClass
    MyClass obj1(42);
    MyClass obj2(42);

    // Displaying data using the displayData member function
    obj1.displayData();
    obj2.displayData();

    // Comparing data using the isEqual member function
    if (obj1.isEqual(obj2)) {
        std::cout << "The data of obj1 and obj2 are equal." << std::endl;
    } else {
        std::cout << "The data of obj1 and obj2 are not equal." << std::endl;
    }

    return 0;
}
In this example:
The MyClass class has a private member variable data.
The displayData member function uses the this pointer to access the member variable and display its value.
The isEqual member function also uses the this pointer to compare the data of the current object with another object.
The this pointer is implicitly available within the member functions of a class, and it can be used to differentiate between local variables and member variables when they have the same name. It provides a way to reference the current object and is particularly useful in scenarios involving member functions and object comparisons.
Short note :-
 Write a note on constructor. 
In object-oriented programming (OOP), a constructor is a special member function of a class that is automatically called when an object of that class is created. Its primary purpose is to initialize the object's data members and perform any setup operations necessary for the object to be in a valid state. Constructors have the same name as the class and do not have a return type.
Here are some key points about constructors:
Initialization:
Constructors initialize the data members of an object. They ensure that an object starts with well-defined values.
Automatic Invocation:
Constructors are automatically called when an object is created. They are responsible for setting up the object before it is used.
Default Constructor:
If a class does not explicitly provide a constructor, C++ generates a default constructor. This default constructor initializes the data members to default values (zero for built-in types).
Parameterized Constructors:
Constructors can take parameters, allowing the caller to provide initial values for the object's data members. This facilitates the creation of objects with different initial states.
class Example {
public:
    // Parameterized constructor
    Example(int initialData) {
        data = initialData;
    }

    void displayData() {
        std::cout << "Data: " << data << std::endl;
    }

private:
    int data;
};

int main() {
    // Creating an object with a parameterized constructor
    Example obj(42);
    obj.displayData();

    return 0;
}
Copy Constructor:
The copy constructor is a special type of constructor that initializes an object using another object of the same class. It is invoked when an object is passed by value, returned by value, or explicitly copied.
class Example {
public:
    // Copy constructor
    Example(const Example& other) {
        data = other.data;
    }

    void displayData() {
        std::cout << "Data: " << data << std::endl;
    }

private:
    int data;
};

int main() {
    // Creating an object and using the copy constructor
    Example original(42);
    Example copy(original);
    copy.displayData();

    return 0;
}
Explain Default constructor. 
A default constructor in C++ is a special constructor that is automatically generated by the compiler if a class doesn't have any constructor defined explicitly. It is a constructor that takes no parameters and provides default initializations for the data members of the class. The default constructor is invoked automatically when an object of the class is created without any explicit arguments.
Here are key points about default constructors:
Automatic Generation:
If a class does not include any user-defined constructors (including parameterized constructors), the C++ compiler generates a default constructor for that class.
No Parameters:
A default constructor takes no parameters. Its primary purpose is to set up the initial state of the object, typically by providing default values for its data members.
Initialization:
The default constructor initializes each data member of the class to its default value. For built-in types (int, double, etc.), this often means zero or a null value.
class Example {
public:
    // Default constructor (implicitly generated)
    Example() {
        // Default initialization for data members
        integerData = 0;
        doubleData = 0.0;
    }

    void displayData() {
        std::cout << "Integer: " << integerData << ", Double: " << doubleData << std::endl;
    }

private:
    int integerData;
    double doubleData;
};

int main() {
    // Creating an object using the default constructor
    Example obj;
    obj.displayData();

    return 0;
}
User-Defined Default Constructor:
If a class includes any constructor (including a parameterized constructor), the compiler does not generate a default constructor. However, the user can explicitly define a default constructor if needed.
class Example {
public:
    // User-defined default constructor
    Example() {
        integerData = 42;
        doubleData = 3.14;
    }

    void displayData() {
        std::cout << "Integer: " << integerData << ", Double: " << doubleData << std::endl;
    }

private:
    int integerData;
    double doubleData;
};

int main() {
    // Creating an object using the user-defined default constructor
    Example obj;
    obj.displayData();

    return 0;
}
Write a note on destructor. 
A destructor in C++ is a special member function of a class that is responsible for cleaning up resources and performing any necessary finalization tasks when an object of that class is about to be destroyed or goes out of scope. The destructor has the same name as the class, preceded by a tilde (~).
Here are key points about destructors:
Automatic Invocation:
Destructors are automatically called when an object is about to be destroyed, either because it goes out of scope or when delete is explicitly used for dynamically allocated objects.
No Parameters:
Destructors do not take any parameters. They have a unique signature that distinguishes them from other member functions.
class Example {
public:
    // Constructor
    Example() {
        std::cout << "Constructor called." << std::endl;
    }

    // Destructor
    ~Example() {
        std::cout << "Destructor called." << std::endl;
    }
};

int main() {
    {
        // Object created, constructor called
        Example obj;
    } // Object goes out of scope, destructor called

    return 0;
}
Output:
Constructor called.
Destructor called.

Differentiate between constructor and destructor. 
Constructors and destructors in C++ are both special member functions associated with classes, but they serve different purposes in the lifecycle of objects. Here are the key differences between constructors and destructors:
Purpose:
Constructor:
Purpose is to initialize the object's data members and set up the object's initial state.
Called when an object is created.
Destructor:
Purpose is to clean up resources and perform any necessary finalization tasks before the object is destroyed.
Called when an object is about to be destroyed, either because it goes out of scope or delete is explicitly used for dynamically allocated objects.
Invocation:
Constructor:
Automatically called when an object is created.
No explicit invocation is needed; it is invoked as part of the object creation process.
Destructor:
Automatically called when an object is about to be destroyed.
No explicit invocation is needed; it is invoked automatically as part of the object destruction process.
Name:
Constructor:
Named after the class, and it has no return type.
Example: Example().
Destructor:
Named after the class, prefixed with a tilde (~), and it has no return type.
Example: ~Example().
Parameters:
Constructor:
May take parameters to allow customization during object creation.
Example: Example(int value).
Destructor:
Takes no parameters; it does not accept any arguments.
Example: ~Example().
Overloading:
Constructor:
Can be overloaded with different parameter lists to provide various ways of initializing objects.
Destructor:
Cannot be overloaded; there can be only one destructor for a class.
Return Type:
Constructor:
Does not have a return type specified.
Example: Example().
Destructor:
Does not have a return type specified.
Example: ~Example().
Multiple Constructors:
Constructor:
A class can have multiple constructors, including default constructors, parameterized constructors, and copy constructors.
Destructor:
A class has only one destructor, and it cannot be overloaded with different parameter lists.
Initialization vs. Cleanup:
Constructor:
Focuses on initializing the object's state and preparing it for use.
Destructor:
Focuses on cleaning up resources, releasing memory, and finalizing operations before the object is destroyed.
Write a note on polymorphism. 

Polymorphism in C++ is a fundamental concept in object-oriented programming that allows objects of different types to be treated as objects of a common base type. The term "polymorphism" is derived from the Greek words "poly" (many) and "morphos" (forms), indicating the ability of a single interface to represent many forms or types.
There are two main types of polymorphism in C++:
Compile-time Polymorphism (Static Binding):
Function Overloading:
Involves defining multiple functions in the same scope with the same name but different parameter lists.
The appropriate function is selected at compile time based on the number or types of arguments provided during the function call.
#include <iostream>

class OverloadedExample {
public:
    void display(int value) {
        std::cout << "Integer value: " << value << std::endl;
    }

    void display(double value) {
        std::cout << "Double value: " << value << std::endl;
    }
};

int main() {
    OverloadedExample obj;
    obj.display(42);       // Calls display(int)
    obj.display(3.14);     // Calls display(double)

    return 0;
}
Operator Overloading:
Allows user-defined classes to redefine the behavior of operators for their instances.
Enables natural syntax for user-defined types.
Run-time Polymorphism (Dynamic Binding):
Function Overriding (Virtual Functions):
Involves defining a function in a base class and allowing derived classes to provide their own implementation.
Achieved using virtual functions and the virtual keyword.
#include <iostream>

class Complex {
public:
    double real;
    double imag;

    Complex operator+(const Complex& other) const {
        Complex result;
        result.real = real + other.real;
        result.imag = imag + other.imag;
        return result;
    }
};

int main() {
    Complex a{1.0, 2.5};
    Complex b{2.5, 1.0};
    Complex sum = a + b;  // Calls operator+ for Complex objects
    std::cout << "Sum: " << sum.real << " + " << sum.imag << "i" << std::endl;

    return 0;
}
Run-time Polymorphism (Dynamic Binding):
Function Overriding (Virtual Functions):
Involves defining a function in a base class and allowing derived classes to provide their own implementation.
Achieved using virtual functions and the virtual keyword.
#include <iostream>

class Base {
public:
    virtual void display() const {
        std::cout << "Base class display" << std::endl;
    }
};

class Derived : public Base {
public:
    void display() const override {
        std::cout << "Derived class display" << std::endl;
    }
};

void showDisplay(const Base& obj) {
    obj.display();
}

int main() {
    Base baseObj;
    Derived derivedObj;

    showDisplay(baseObj);    // Calls Base class display
    showDisplay(derivedObj); // Calls Derived class display

    return 0;
}Explain the concept of operator overloading. 
Operator overloading in C++ allows you to redefine the behavior of operators for user-defined data types or classes. This enables objects of a class to be used with familiar operators, providing a more natural and intuitive syntax. Operator overloading is a form of compile-time polymorphism, as the specific operator to be used is determined at compile time based on the types involved in the operation.
Here are the key points about operator overloading:
Syntax:
Operator overloading is achieved by defining a function for a specific operator in the class.
The function is called an "overloaded operator function" and has a specific syntax, such as operator+, operator-, etc.
class Complex {
public:
    double real;
    double imag;

    Complex operator+(const Complex& other) const {
        Complex result;
        result.real = real + other.real;
        result.imag = imag + other.imag;
        return result;
    }
};

(👈Uint-1 Previous - Next unit-3 👉)