1.

Explain the difference between overloading an operator as a member

function and as a friend function in a class.

Answer:

Member Function:
A member function is used to overload an operator when the left operand is an object of the
class. The function has implicit access to the private and protected members of the class it
belongs to. It requires a single argument for binary operators (the right-hand operand).
Example:
cpp
Copy code
class Number {
int value;
public:
Number(int v) : value(v) {}
Number operator+(const Number& other) { return Number(value +
other.value); }
};

Friend Function:
A friend function is defined outside the class but has access to its private and protected
members. It is useful when the left operand is not an object of the class, such as when dealing
with primitive data types or objects from other classes. It requires two arguments for binary
operators (the left and right operands).
Example:
cpp
Copy code
class Number {
int value;
friend Number operator+(const Number& a, const Number& b);
public:
Number(int v) : value(v) {}
};

Number operator+(const Number& a, const Number& b) {

return Number(a.value + b.value);
}
 ●

2. Discuss the rules for returning values from overloaded operator

functions. Are there any best practices to follow?

Answer:

● Rules for Returning Values:

1. Use by value return type for operators like +, -, *, / where a new object is
created as the result.
2. Use by reference return type for operators like = or +=, which modify the existing
object and return it.
3. For increment (++) and decrement (--) operators, ensure correct differentiation
between pre-increment and post-increment.
● Best Practices:
1. Return const objects by value to prevent modification of the temporary object.
2. Return *this by reference for assignment operators to allow chaining.
3. Avoid returning references to local variables, as they go out of scope after the
function returns.

Example:
cpp
Copy code
class Number {
int value;
public:
Number(int v) : value(v) {}
Number operator+(const Number& other) const { return Number(value
+ other.value); }
Number& operator=(const Number& other) {
value = other.value;
return *this;
}

● };

3. Assess the advantages and disadvantages of implementing custom

operators and overloading them in C++.

Answer:
Advantages:

1. Enhanced Readability: Custom operators make code more intuitive and align
operations with domain logic.
Example: Adding complex numbers using + instead of a function like addComplex().
2. Reusability: Operators can be reused across different objects of the same class,
improving modularity.
3. Consistency: Provides the ability to mimic standard operator behavior for custom data
types (e.g., string concatenation, matrix addition).

Disadvantages:

1. Complexity: Overuse of overloaded operators can make code less readable, especially
for unconventional use.
2. Debugging Difficulty: Bugs related to operator overloading are harder to trace,
especially when they deviate from expected behavior.
3. Performance Overhead: Improper implementation can lead to inefficient operations and
increased memory usage.

4. Compare and contrast the restrictions on overloading unary and binary

operators in C++.

Answer:
Unary Operators:

● Only one operand is involved.

● Examples: ++, --, !, ~.
● Can be overloaded as member or friend functions but take no arguments as member
functions and one argument as friend functions.

Binary Operators:

● Involves two operands.

● Examples: +, -, *, /.
● Requires one argument for member functions and two arguments for friend functions.

Restrictions:

1. Certain operators (::, sizeof, .) cannot be overloaded.

2. Overloading should preserve the logical meaning of the operator to avoid confusion.

Comparison Example: Unary ++:

cpp
Copy code
Number& operator++(); // Prefix
Number operator++(int); // Postfix

Binary +:

cpp
Copy code
Number operator+(const Number& other);

5. Describe the special restrictions for overloading comparison operators

in C++.

Answer:

1. Comparison operators (<, >, <=, >=, ==, !=) must return a boolean value (true or
false).
2. They are typically overloaded as member or friend functions.
3. Should adhere to logical equivalence and ordering rules (e.g., == should behave as the
negation of !=).
4. Best practice involves pairing operators (e.g., overload both == and !=, < and >).

Example:

cpp
Copy code
class Number {
int value;
public:
Number(int v) : value(v) {}
bool operator==(const Number& other) const { return value ==
other.value; }
bool operator!=(const Number& other) const { return value !=
other.value; }
};
6. Summarize the advantages and disadvantages of using friend functions.

Answer:

Advantages:

1. Access Private Data: Allows access to private/protected members without

compromising encapsulation.
2. Improved Code Organization: Can simplify certain operations like comparisons or
binary operations.
3. Flexibility: Enables overloading operators where the left operand is not a class object.

Disadvantages:

1. Encapsulation Risk: Increases dependency on internal details, violating strict

encapsulation principles.
2. Tight Coupling: May lead to tighter coupling between classes or functions.
3. Maintenance Overhead: Increases complexity, making changes harder to manage.

Would you like me to continue?

4o

You said:
yes

ChatGPT said:
ChatGPT

7. Describe the differences between friend functions and member functions

in C++ classes.

Answer:

Aspect Friend Functions Member Functions

Definition Defined outside the class but declared as Defined inside the class.
a friend inside the class.

Access Can access private and protected Has implicit access to the
members of the class. class's private and protected
members.
Syntax Requires the friend keyword in the class Does not require special
definition. syntax.

Operand Can operate on objects of other classes or Operates only on the invoking
Flexibility primitive data types. object and arguments.

Use Cases Useful for non-member operations Used for class-specific

requiring access to class internals (e.g., operations (e.g., assignment,
binary operator overloads). member updates).

8. Compare and contrast the usage of friend functions in C++ with other
techniques for accessing private class members.

Answer:

Technique Description Advantages Disadvantages

Friend Functions declared with Simplifies access Tightens coupling

Functions friend, granting without exposing between function
access to implementation. and class.
private/protected
members.

Getters/Setters Public methods to Encapsulation remains Increased boilerplate

access private data. intact. code for accessing
and modifying
members.

Inheritance Protected members Allows access within a Restricted to derived

accessed via derived hierarchy while classes only; can
classes. maintaining complicate design.
encapsulation for
unrelated classes.

Structs/Public All members are public. Simplest access method Violates

Members for lightweight objects. encapsulation
entirely.

9. Assess the design choices in a C++ program that uses friend functions,
considering their effects on encapsulation and code maintainability.

Answer:
 ● Advantages:
1. Simplifies complex operations by avoiding excessive getter/setter use.
2. Reduces code duplication when multiple classes require access to internal data
for cooperative operations.
3. Enhances readability for binary operator overloads.
● Disadvantages:
1. Violates encapsulation principles by exposing internals to external functions.
2. Makes code maintenance harder if changes are needed in class internals, as it
impacts all friend functions.
3. Increases dependency and coupling, reducing modularity.

Best Practices:

1. Use friend functions sparingly for well-justified scenarios.

2. Clearly document the purpose of friend functions to avoid misuse.
3. Combine with encapsulation-friendly techniques like abstract interfaces for long-term
maintainability.

10. Develop a C++ program that demonstrates the effective use of friend
functions in solving a specific problem.

Answer:

Problem: Create two classes, Rectangle and Square. Use a friend function to compare their
areas.

Code Example:

cpp
Copy code
#include <iostream>
using namespace std;

class Square; // Forward declaration

class Rectangle {
int length, width;
public:
Rectangle(int l, int w) : length(l), width(w) {}
friend bool compareArea(const Rectangle& rect, const Square& sq);
};
class Square {
int side;
public:
Square(int s) : side(s) {}
friend bool compareArea(const Rectangle& rect, const Square& sq);
};

bool compareArea(const Rectangle& rect, const Square& sq) {

int rectArea = rect.length * rect.width;
int squareArea = sq.side * sq.side;
return rectArea > squareArea;
}

int main() {
Rectangle rect(10, 5);
Square sq(6);

if (compareArea(rect, sq))
cout << "Rectangle has a larger area than Square." << endl;
else
cout << "Square has a larger area than Rectangle." << endl;

return 0;
}

Explanation:

● The friend function compareArea accesses private data of both Rectangle and
Square classes to calculate and compare their areas.
● Demonstrates encapsulation and cooperative functionality between classes.

11. Discuss whether overloaded unary operators can be friend functions

and under what circumstances.

Answer:

● Unary operators (e.g., ++, --, !) can indeed be overloaded as friend functions, though
this is less common.
 ● When to Use Friend Functions for Unary Operators:
1. If the unary operation involves access to private or protected members of the
class.
2. When the unary operator's behavior needs to operate outside the
member-function paradigm.

Example: Overloading ! as a friend function:

cpp
Copy code
#include <iostream>
using namespace std;

class Number {
int value;
public:
Number(int v) : value(v) {}
friend bool operator!(const Number& num);
};

bool operator!(const Number& num) {

return num.value == 0;
}

int main() {
Number n1(0), n2(10);
cout << (!n1 ? "n1 is zero" : "n1 is non-zero") << endl;
cout << (!n2 ? "n2 is zero" : "n2 is non-zero") << endl;
return 0;
}

Explanation:
Here, the ! operator is overloaded to check if the value is zero. The friend function accesses
private data directly.

12. Create an example of how you could overload the unary ++ operator to
increment the temperature by a specified amount and return the updated
temperature. Demonstrate this overloading in code and explain the logic
behind it.

Answer:

Code Example:

cpp
Copy code
#include <iostream>
using namespace std;

class Temperature {
float temp;
public:
Temperature(float t) : temp(t) {}

// Overloading prefix ++
Temperature& operator++() {
temp += 5; // Increment temperature by 5
return *this;
}

// Overloading postfix ++
Temperature operator++(int) {
Temperature old = *this;
temp += 5;
return old;
}

void display() const {

cout << "Temperature: " << temp << "°C" << endl;
}
};

int main() {
Temperature t(25.0);

cout << "Initial ";

t.display();
 cout << "After Prefix Increment ";
++t;
t.display();

cout << "After Postfix Increment ";

t++;
t.display();

return 0;
}

Explanation:

1. Prefix ++: Directly increments the temperature and returns the updated object.
2. Postfix ++: Creates a copy of the object, increments the original, and returns the copy to
simulate the traditional behavior.
3. Increments are by 5 units as an example of custom logic.

13. Provide the C++ code to overload the unary + operator for the
Complex_Number class, and demonstrate how this operator is used to
achieve the desired operation.

Answer:

Code Example:

cpp
Copy code
#include <iostream>
using namespace std;

class Complex_Number {
float real, imag;
public:
Complex_Number(float r = 0, float i = 0) : real(r), imag(i) {}

// Unary + operator overload

 Complex_Number operator+() const {
return Complex_Number(+real, +imag);
}

void display() const {

cout << real << " + " << imag << "i" << endl;
}
};

int main() {
Complex_Number c1(-3.2, 4.5);

cout << "Original: ";

c1.display();

Complex_Number c2 = +c1;
cout << "After Unary + : ";
c2.display();

return 0;
}

Explanation:

● The unary + operator simply returns a new Complex_Number object, retaining the sign
of the real and imaginary parts.
● This is useful for enforcing the use of the + operator on complex numbers in equations or
operations.

Would you like me to proceed with the next questions?

4o

You said:
yes

ChatGPT said:
ChatGPT
14. Design a C++ program that simulates a car's speedometer. Utilize the ++
operator to increase the speed and the -- operator to decrease it. Include
features like speed limits and warnings.

Answer:

Code Example:

cpp
Copy code
#include <iostream>
using namespace std;

class Speedometer {
int speed;
const int MAX_SPEED = 200;
const int MIN_SPEED = 0;

public:
Speedometer(int s = 0) : speed(s) {}

// Overload prefix ++ to increase speed

Speedometer& operator++() {
if (speed + 10 > MAX_SPEED) {
speed = MAX_SPEED;
cout << "Warning: Maximum speed reached!" << endl;
} else {
speed += 10;
}
return *this;
}

// Overload prefix -- to decrease speed

Speedometer& operator--() {
if (speed - 10 < MIN_SPEED) {
speed = MIN_SPEED;
cout << "Warning: Minimum speed reached!" << endl;
} else {
speed -= 10;
 }
return *this;
}

void displaySpeed() const {

cout << "Current Speed: " << speed << " km/h" << endl;
}
};

int main() {
Speedometer carSpeed(50);

carSpeed.displaySpeed();
++carSpeed; // Increase speed
carSpeed.displaySpeed();
--carSpeed; // Decrease speed
carSpeed.displaySpeed();

for (int i = 0; i < 20; ++i) ++carSpeed; // Test max speed

carSpeed.displaySpeed();

for (int i = 0; i < 10; ++i) --carSpeed; // Test min speed

carSpeed.displaySpeed();

return 0;
}

Explanation:

● The ++ operator increases the speed by 10 units, with a warning when hitting the
maximum speed.
● The -- operator decreases the speed by 10 units, with a warning when hitting the
minimum speed.
● The program enforces speed limits to prevent invalid speed values.

15. Construct a comprehensive C++ program that utilizes both the unary ++
and -- operators.
Answer:

Code Example:

cpp
Copy code
#include <iostream>
using namespace std;

class Counter {
int value;
public:
Counter(int v = 0) : value(v) {}

// Overload prefix ++
Counter& operator++() {
++value;
return *this;
}

// Overload prefix --
Counter& operator--() {
if (value > 0)
--value;
return *this;
}

// Overload postfix ++
Counter operator++(int) {
Counter temp = *this;
++value;
return temp;
}

// Overload postfix --
Counter operator--(int) {
Counter temp = *this;
if (value > 0)
--value;
return temp;
 }

void display() const {

cout << "Counter Value: " << value << endl;
}
};

int main() {
Counter c(5);

c.display();

cout << "Using Prefix ++:" << endl;

++c;
c.display();

cout << "Using Postfix ++:" << endl;

c++;
c.display();

cout << "Using Prefix --:" << endl;

--c;
c.display();

cout << "Using Postfix --:" << endl;

c--;
c.display();

return 0;
}

Explanation:

● Prefix operators update the object immediately and return the updated object.
● Postfix operators save the current state, update the object, and return the saved state.
● This example demonstrates both forms for incrementing and decrementing, with
validations for logical behavior.
16. Develop a C++ program that demonstrates the overloading of the +
operator for user-defined objects. Provide a scenario where this operator is
beneficial, and discuss the steps involved in operator overloading.

Answer:

Code Example:

cpp
Copy code
#include <iostream>
#include <string>
using namespace std;

class Book {
string title;
int pages;
public:
Book(string t = "", int p = 0) : title(t), pages(p) {}

// Overload + operator
Book operator+(const Book& other) const {
return Book(title + " & " + other.title, pages + other.pages);
}

void display() const {

cout << "Title: " << title << ", Pages: " << pages << endl;
}
};

int main() {
Book b1("C++ Basics", 300);
Book b2("Advanced C++", 450);

cout << "Book 1: ";

b1.display();
cout << "Book 2: ";
b2.display();

Book combined = b1 + b2;

 cout << "Combined Book: ";
combined.display();

return 0;
}

Explanation:

● The + operator is overloaded to combine two Book objects by concatenating their titles
and summing up the pages.
● Useful in applications that merge or summarize object information.

17. Create a complex C++ program that uses multiple binary operator
overloads to perform operations between objects of a custom class.
Discuss the design considerations for such operator overloads.

Answer:

Code Example:

cpp
Copy code
#include <iostream>
using namespace std;

class Time {
int hours, minutes;
public:
Time(int h = 0, int m = 0) : hours(h), minutes(m) {}

// Overload + for adding two Time objects

Time operator+(const Time& other) const {
int totalMinutes = (hours + other.hours) * 60 + minutes +
other.minutes;
return Time(totalMinutes / 60, totalMinutes % 60);
}
 // Overload - for subtracting two Time objects
Time operator-(const Time& other) const {
int totalMinutes = (hours * 60 + minutes) - (other.hours * 60
+ other.minutes);
if (totalMinutes < 0) totalMinutes = 0;
return Time(totalMinutes / 60, totalMinutes % 60);
}

void display() const {

cout << hours << " hours and " << minutes << " minutes" <<
endl;
}
};

int main() {
Time t1(2, 45);
Time t2(1, 30);

cout << "Time 1: ";

t1.display();
cout << "Time 2: ";
t2.display();

Time t3 = t1 + t2;
cout << "Sum of Times: ";
t3.display();

Time t4 = t1 - t2;
cout << "Difference of Times: ";
t4.display();

return 0;
}

Explanation:

● Overloads + to calculate the sum of times and - to calculate their difference.

● Design considerations include ensuring valid results and handling edge cases like
negative time values.
18. Create a C++ program for implementing a "Matrix" class. Overload the +
operator to enable matrix addition and the * operator for scalar
multiplication. Develop a matrix calculator allowing users to input two
matrices and select the desired operation, either addition or multiplication.

Answer:

Code Example:

cpp
Copy code
#include <iostream>
#include <vector>
using namespace std;

class Matrix {
vector<vector<int>> mat;
int rows, cols;
public:
Matrix(int r, int c) : rows(r), cols(c), mat(r, vector<int>(c, 0))
{}

void input() {
cout << "Enter matrix elements:\n";
for (int i = 0; i < rows; ++i)
for (int j = 0; j < cols; ++j)
cin >> mat[i][j];
}

// Overload + for matrix addition

Matrix operator+(const Matrix& other) const {
if (rows != other.rows || cols != other.cols)
throw invalid_argument("Matrix dimensions do not match for
addition.");

Matrix result(rows, cols);

for (int i = 0; i < rows; ++i)
for (int j = 0; j < cols; ++j)
 result.mat[i][j] = mat[i][j] + other.mat[i][j];
return result;
}

// Overload * for scalar multiplication

Matrix operator*(int scalar) const {
Matrix result(rows, cols);
for (int i = 0; i < rows; ++i)
for (int j = 0; j < cols; ++j)
result.mat[i][j] = mat[i][j] * scalar;
return result;
}

void display() const {

for (const auto& row : mat) {
for (int val : row)
cout << val << " ";
cout << endl;
}
}
};

int main() {
int r, c;
cout << "Enter rows and columns for matrices: ";
cin >> r >> c;

Matrix m1(r, c), m2(r, c);

cout << "Matrix 1:\n";
m1.input();
cout << "Matrix 2:\n";
m2.input();

cout << "Matrix Addition:\n";

Matrix sum = m1 + m2;
sum.display();

cout << "Matrix Scalar Multiplication (Matrix 1 * 2):\n";

 Matrix scaled = m1 * 2;
scaled.display();

return 0;
}

Explanation:

● Overloads + for matrix addition and * for scalar multiplication.

● Input validation ensures matrices have compatible dimensions for addition.
● The program allows the user to perform matrix operations interactively.

19. Develop a C++ class for a "ShoppingCart" with items and prices.
Overload the + operator to combine two shopping carts. Build a program
that enables users to add items to their shopping carts, calculate the total
cost, and merge two shopping carts into one.

Answer:

Code Example:

cpp
Copy code
#include <iostream>
#include <vector>
#include <string>
using namespace std;

class ShoppingCart {
vector<pair<string, double>> items;

public:
void addItem(const string& itemName, double price) {
items.emplace_back(itemName, price);
}

ShoppingCart operator+(const ShoppingCart& other) const {

ShoppingCart combined = *this;
combined.items.insert(combined.items.end(),
other.items.begin(), other.items.end());
 return combined;
}

double calculateTotal() const {

double total = 0;
for (const auto& item : items)
total += item.second;
return total;
}

void displayCart() const {

cout << "Shopping Cart:" << endl;
for (const auto& item : items)
cout << "- " << item.first << ": $" << item.second <<
endl;
cout << "Total: $" << calculateTotal() << endl;
}
};

int main() {
ShoppingCart cart1, cart2;

cart1.addItem("Apple", 1.2);
cart1.addItem("Bread", 2.5);

cart2.addItem("Milk", 3.0);
cart2.addItem("Eggs", 4.5);

cout << "Cart 1:" << endl;

cart1.displayCart();

cout << "\nCart 2:" << endl;

cart2.displayCart();

ShoppingCart mergedCart = cart1 + cart2;

cout << "\nMerged Cart:" << endl;
mergedCart.displayCart();
 return 0;
}

Explanation:

● Items are stored as pair<string, double> for names and prices.

● The + operator merges the items from two shopping carts.
● The calculateTotal method computes the total cost of the cart.

20. Construct a C++ class for complex numbers and overload the *
operator for complex number multiplication. Write a program that multiplies
two complex numbers and provides insights into operator overloading for
this mathematical operation.

Answer:

Code Example:

cpp
Copy code
#include <iostream>
using namespace std;

class Complex {
double real, imag;

public:
Complex(double r = 0, double i = 0) : real(r), imag(i) {}

Complex operator*(const Complex& other) const {

double r = real * other.real - imag * other.imag;
double i = real * other.imag + imag * other.real;
return Complex(r, i);
}

void display() const {

cout << real << " + " << imag << "i" << endl;
}
};

int main() {
Complex c1(3, 2), c2(4, 5);

cout << "Complex Number 1: ";

c1.display();

cout << "Complex Number 2: ";

c2.display();

Complex result = c1 * c2;

cout << "Result of Multiplication: ";

result.display();

return 0;
}

Explanation:

● Implements the formula (a+bi)(c+di) = (ac-bd) + (ad+bc)i.

● The * operator handles the logic for multiplying complex numbers.

21. Develop a C++ class for fractions and overload the + operator to add
two fractions together. Write a program that computes the sum of two
fractions and explains the operator overloading involved.

Answer:

Code Example:

cpp
Copy code
#include <iostream>
#include <numeric>
using namespace std;
class Fraction {
int numerator, denominator;

public:
Fraction(int num = 0, int den = 1) : numerator(num),
denominator(den) {
if (den == 0) throw invalid_argument("Denominator cannot be
zero.");
simplify();
}

Fraction operator+(const Fraction& other) const {

int num = numerator * other.denominator + other.numerator *
denominator;
int den = denominator * other.denominator;
return Fraction(num, den);
}

void simplify() {
int gcd = std::gcd(numerator, denominator);
numerator /= gcd;
denominator /= gcd;
}

void display() const {

cout << numerator << "/" << denominator << endl;
}
};

int main() {
Fraction f1(3, 4), f2(5, 6);

cout << "Fraction 1: ";

f1.display();
cout << "Fraction 2: ";
f2.display();

Fraction result = f1 + f2;

 cout << "Sum of Fractions: ";
result.display();

return 0;
}

Explanation:

● The + operator computes the numerator and denominator for the sum of two fractions.
● The simplify method reduces the fraction to its simplest form using the greatest
common divisor.

22. Develop a C++ class representing a bank account and use a friend
function to overload the + operator to add the balances of two accounts.
Create a program to demonstrate this operator overloading using friend
functions.

Answer:

Code Example:

cpp
Copy code
#include <iostream>
using namespace std;

class BankAccount {
double balance;

public:
BankAccount(double bal = 0) : balance(bal) {}

// Friend function to overload + operator

friend BankAccount operator+(const BankAccount& acc1, const
BankAccount& acc2);

void displayBalance() const {

cout << "Balance: $" << balance << endl;
}
};

BankAccount operator+(const BankAccount& acc1, const BankAccount&

acc2) {
return BankAccount(acc1.balance + acc2.balance);
}

int main() {
BankAccount acc1(1500.50), acc2(2300.75);

cout << "Account 1: ";

acc1.displayBalance();
cout << "Account 2: ";
acc2.displayBalance();

BankAccount mergedAccount = acc1 + acc2;

cout << "Merged Account: ";

mergedAccount.displayBalance();

return 0;
}

Explanation:

● The + operator is overloaded as a friend function to access private data members of

both accounts.
● It creates a new BankAccount object with the combined balance.

23. Construct a C++ class for complex numbers and use a friend function to
overload the * operator for complex number multiplication. Write a
program to multiply two complex numbers using the overloaded operator,
implemented as a friend function.

Answer:

Code Example:
cpp
Copy code
#include <iostream>
using namespace std;

class Complex {
double real, imag;

public:
Complex(double r = 0, double i = 0) : real(r), imag(i) {}

// Friend function to overload * operator

friend Complex operator*(const Complex& c1, const Complex& c2);

void display() const {

cout << real << " + " << imag << "i" << endl;
}
};

Complex operator*(const Complex& c1, const Complex& c2) {

double r = c1.real * c2.real - c1.imag * c2.imag;
double i = c1.real * c2.imag + c1.imag * c2.real;
return Complex(r, i);
}

int main() {
Complex c1(3, 2), c2(4, 5);

cout << "Complex Number 1: ";

c1.display();
cout << "Complex Number 2: ";
c2.display();

Complex result = c1 * c2;

cout << "Result of Multiplication: ";

result.display();

return 0;
}

Explanation:

● The * operator is implemented as a friend function to enable access to private data

members.
● It adheres to the formula for multiplying complex numbers.

24. Examine the use of friend functions in operator overloading in C++,

illustrated through a custom String class that overloads the + operator for
string concatenation. Evaluate the steps and key considerations in
implementing friend functions.

Answer:

Code Example:

cpp
Copy code
#include <iostream>
#include <string>
using namespace std;

class String {
string str;

public:
String(const string& s = "") : str(s) {}

// Friend function to overload + operator

friend String operator+(const String& s1, const String& s2);

void display() const {

cout << str << endl;
}
};

String operator+(const String& s1, const String& s2) {

 return String(s1.str + s2.str);
}

int main() {
String s1("Hello, "), s2("World!");

cout << "String 1: ";

s1.display();
cout << "String 2: ";
s2.display();

String result = s1 + s2;

cout << "Concatenated String: ";

result.display();

return 0;
}

Key Considerations:

● Friend functions allow access to private members of the class, enabling string
concatenation without additional accessors.
● Proper management of memory and string validation is essential.

26. Create a base class Shape with attributes for length and width. Derive
a class Rectangle from Shape and implement a method to calculate its
area. Create an object of Rectangle and calculate its area.

Answer:

Code Example:

cpp
Copy code
#include <iostream>
using namespace std;
class Shape {
protected:
double length, width;

public:
Shape(double l = 0, double w = 0) : length(l), width(w) {}
};

class Rectangle : public Shape {

public:
Rectangle(double l, double w) : Shape(l, w) {}

double calculateArea() const {

return length * width;
}
};

int main() {
Rectangle rect(5.0, 3.0);
cout << "Area of Rectangle: " << rect.calculateArea() << endl;

return 0;
}

Explanation:

● The Rectangle class inherits from Shape and utilizes protected attributes for area
calculation.
● Polymorphism is not required as the functionality is specific to rectangles.

27. Define a base class Person with attributes like name and age. Create
two classes, Student and Employee, inheriting from Person. Implement
methods to display student details and employee details. Create objects for
both and display their information.

Answer:

Code Example:
cpp
Copy code
#include <iostream>
#include <string>
using namespace std;

class Person {
protected:
string name;
int age;

public:
Person(const string& n, int a) : name(n), age(a) {}
virtual ~Person() {}
};

class Student : public Person {

string major;

public:
Student(const string& n, int a, const string& m) : Person(n, a),
major(m) {}

void displayDetails() const {

cout << "Student Name: " << name << "\nAge: " << age <<
"\nMajor: " << major << endl;
}
};

class Employee : public Person {

string department;

public:
Employee(const string& n, int a, const string& d) : Person(n, a),
department(d) {}

void displayDetails() const {

cout << "Employee Name: " << name << "\nAge: " << age <<
"\nDepartment: " << department << endl;
 }
};

int main() {
Student student("Alice", 20, "Computer Science");
Employee employee("Bob", 35, "Human Resources");

cout << "Student Details:" << endl;

student.displayDetails();

cout << "\nEmployee Details:" << endl;

employee.displayDetails();

return 0;
}

Explanation:

● The Person class contains common attributes name and age.

● Student and Employee inherit from Person and include unique attributes like major
and department.
● Methods in derived classes display respective details.

28. Create a base class Vehicle with attributes like make and model.
Derive a class Car from Vehicle, and then create a class SportsCar from
Car. Implement methods to display the make and model of each class.
Create a SportsCar object and display its details.

Answer:

Code Example:

cpp
Copy code
#include <iostream>
#include <string>
using namespace std;
class Vehicle {
protected:
string make, model;

public:
Vehicle(const string& m, const string& mod) : make(m), model(mod)
{}
virtual ~Vehicle() {}

void displayDetails() const {

cout << "Make: " << make << ", Model: " << model << endl;
}
};

class Car : public Vehicle {

public:
Car(const string& m, const string& mod) : Vehicle(m, mod) {}
};

class SportsCar : public Car {

double topSpeed;

public:
SportsCar(const string& m, const string& mod, double speed) :
Car(m, mod), topSpeed(speed) {}

void displayDetails() const {

Vehicle::displayDetails();
cout << "Top Speed: " << topSpeed << " km/h" << endl;
}
};

int main() {
SportsCar sc("Ferrari", "488 Spider", 330.0);

cout << "SportsCar Details:" << endl;

sc.displayDetails();
 return 0;
}

Explanation:

● Vehicle provides basic attributes and methods.

● Car inherits from Vehicle with no additional attributes.
● SportsCar adds a specific feature, topSpeed, and overrides the displayDetails
method.

29. Design a base class Vehicle with attributes like make and model.
Derive two classes, Car and Motorcycle, from Vehicle. Implement
methods for each class to display their details, including make and model.
Create objects for both Car and Motorcycle and display their details.

Answer:

Code Example:

cpp
Copy code
#include <iostream>
#include <string>
using namespace std;

class Vehicle {
protected:
string make, model;

public:
Vehicle(const string& m, const string& mod) : make(m), model(mod)
{}

virtual void displayDetails() const {

cout << "Make: " << make << ", Model: " << model << endl;
}
};
class Car : public Vehicle {
public:
Car(const string& m, const string& mod) : Vehicle(m, mod) {}

void displayDetails() const override {

cout << "Car Details -> ";
Vehicle::displayDetails();
}
};

class Motorcycle : public Vehicle {

public:
Motorcycle(const string& m, const string& mod) : Vehicle(m, mod)
{}

void displayDetails() const override {

cout << "Motorcycle Details -> ";
Vehicle::displayDetails();
}
};

int main() {
Car car("Toyota", "Corolla");
Motorcycle motorcycle("Yamaha", "MT-07");

car.displayDetails();
motorcycle.displayDetails();

return 0;
}

Explanation:

● Vehicle is the base class for both Car and Motorcycle.

● Polymorphic behavior is demonstrated with the displayDetails method.
30. Create a base class named Shape with attributes such as color and
area. Derive two classes, Circle and Rectangle, from the Shape class.
Implement methods in each class to calculate and return their respective
areas. Create instances of both the Circle and Rectangle classes,
calculate their areas, and display the results.

Answer:

Code Example:

cpp
Copy code
#include <iostream>
#include <cmath>
using namespace std;

class Shape {
protected:
string color;

public:
Shape(const string& c) : color(c) {}
virtual double calculateArea() const = 0; // Pure virtual function

void displayColor() const {

cout << "Color: " << color << endl;
}
};

class Circle : public Shape {

double radius;

public:
Circle(const string& c, double r) : Shape(c), radius(r) {}

double calculateArea() const override {

return M_PI * radius * radius;
}
};
class Rectangle : public Shape {
double length, width;

public:
Rectangle(const string& c, double l, double w) : Shape(c),
length(l), width(w) {}

double calculateArea() const override {

return length * width;
}
};

int main() {
Circle circle("Red", 5.0);
Rectangle rectangle("Blue", 4.0, 6.0);

cout << "Circle Details:" << endl;

circle.displayColor();
cout << "Area: " << circle.calculateArea() << endl;

cout << "\nRectangle Details:" << endl;

rectangle.displayColor();
cout << "Area: " << rectangle.calculateArea() << endl;

return 0;
}

Explanation:

● Abstract base class Shape contains a pure virtual function for calculating area.
● Derived classes Circle and Rectangle implement the calculateArea method.

31. Develop a base class Shape with attributes like color and area. Derive
two classes, Circle and Rectangle, from Shape. Add methods to
compute their areas. Instantiate objects of both classes, calculate their
areas, and display the results.
Answer:

Code Example:

cpp
Copy code
#include <iostream>
#include <cmath>
using namespace std;

class Shape {
protected:
string color;

public:
Shape(const string& c) : color(c) {}
virtual double calculateArea() const = 0; // Pure virtual function

void displayColor() const {

cout << "Color: " << color << endl;
}
};

class Circle : public Shape {

double radius;

public:
Circle(const string& c, double r) : Shape(c), radius(r) {}

double calculateArea() const override {

return M_PI * radius * radius;
}
};

class Rectangle : public Shape {

double length, width;

public:
Rectangle(const string& c, double l, double w) : Shape(c),
length(l), width(w) {}
 double calculateArea() const override {
return length * width;
}
};

int main() {
Circle circle("Red", 5.0);
Rectangle rectangle("Blue", 4.0, 6.0);

cout << "Circle Details:" << endl;

circle.displayColor();
cout << "Area: " << circle.calculateArea() << endl;

cout << "\nRectangle Details:" << endl;

rectangle.displayColor();
cout << "Area: " << rectangle.calculateArea() << endl;

return 0;
}

Explanation:

● This example uses polymorphism where the base class Shape defines the interface for
calculating the area, and the derived classes Circle and Rectangle implement it.
● The calculateArea() method is abstract in the base class, and implemented in the
derived classes.

32. Create a C++ program with multiple levels of inheritance, including a

virtual base class. Demonstrate how the virtual base class resolves
ambiguity in member access. Discuss the potential issues it helps to avoid.

Answer:

Code Example:

cpp
Copy code
#include <iostream>
using namespace std;

class A {
public:
A() {
cout << "A constructor\n";
}
void showA() {
cout << "Class A\n";
}
};

class B : virtual public A {

public:
B() {
cout << "B constructor\n";
}
void showB() {
cout << "Class B\n";
}
};

class C : virtual public A {

public:
C() {
cout << "C constructor\n";
}
void showC() {
cout << "Class C\n";
}
};

class D : public B, public C {

public:
D() {
cout << "D constructor\n";
}
 void showD() {
cout << "Class D\n";
}
};

int main() {
D obj;
obj.showA(); // Calls A::showA() through virtual inheritance
obj.showB();
obj.showC();
obj.showD();
return 0;
}

Explanation:

● Classes B and C virtually inherit from A to avoid ambiguity when D inherits from both B
and C.
● Virtual inheritance ensures only one instance of A is inherited, preventing multiple copies
of A when the derived class D inherits from both B and C.
● This mechanism helps avoid issues where the same base class would be inherited more
than once, leading to ambiguity and extra overhead.

33. Develop a C++ program with multiple inheritance levels and virtual base
classes. Explain the order of constructor and destructor calls in such a
hierarchy and discuss how virtual base classes impact this order.

Answer:

Code Example:

cpp
Copy code
#include <iostream>
using namespace std;

class A {
public:
 A() {
cout << "A constructor\n";
}
virtual ~A() {
cout << "A destructor\n";
}
};

class B : public virtual A {

public:
B() {
cout << "B constructor\n";
}
virtual ~B() {
cout << "B destructor\n";
}
};

class C : public virtual A {

public:
C() {
cout << "C constructor\n";
}
virtual ~C() {
cout << "C destructor\n";
}
};

class D : public B, public C {

public:
D() {
cout << "D constructor\n";
}
virtual ~D() {
cout << "D destructor\n";
}
};
int main() {
D obj;
return 0;
}

Explanation:

● Virtual inheritance ensures that the constructor of the virtual base class A is called only
once, even though it is inherited by both B and C.
● The constructor call order is as follows:
○ First, the constructor of A is called (the virtual base class).
○ Then the constructors of B and C are called.
○ Finally, the constructor of D is called.
● Destructor calls happen in reverse order: the destructor of D is called first, followed by C,
B, and finally A.

34. Implement a program that showcases the use of virtual base classes in
a real-world application. Explain how virtual inheritance simplifies the
design and structure of your program.

Answer:

Code Example:

cpp
Copy code
#include <iostream>
using namespace std;

class Employee {
public:
Employee() {
cout << "Employee constructor\n";
}
virtual ~Employee() {
cout << "Employee destructor\n";
}
virtual void work() {
 cout << "Employee working\n";
}
};

class Manager : virtual public Employee {

public:
Manager() {
cout << "Manager constructor\n";
}
virtual ~Manager() {
cout << "Manager destructor\n";
}
void work() override {
cout << "Manager managing\n";
}
};

class Developer : virtual public Employee {

public:
Developer() {
cout << "Developer constructor\n";
}
virtual ~Developer() {
cout << "Developer destructor\n";
}
void work() override {
cout << "Developer coding\n";
}
};

class TechLead : public Manager, public Developer {

public:
TechLead() {
cout << "TechLead constructor\n";
}
~TechLead() {
cout << "TechLead destructor\n";
}
 void work() override {
cout << "TechLead coordinating\n";
}
};

int main() {
TechLead tl;
tl.work();
return 0;
}

Explanation:

● This example demonstrates a real-world application where Manager and Developer

are virtually inherited from Employee to ensure only one instance of Employee exists in
TechLead.
● The virtual inheritance simplifies the design by avoiding redundant base class data and
ensuring a more efficient inheritance structure.
● The work method is overridden in Manager, Developer, and TechLead, showcasing
polymorphism and virtual functions.

35. Explore the concept of "function overriding" in the context of virtual

functions and polymorphism in C++. Provide an example where a derived
class overrides a virtual function from the base class.

Answer:

Code Example:

cpp
Copy code
#include <iostream>
using namespace std;

class Animal {
public:
virtual void sound() {
cout << "Animal makes a sound\n";
}
};
class Dog : public Animal {
public:
void sound() override {
cout << "Dog barks\n";
}
};

class Cat : public Animal {

public:
void sound() override {
cout << "Cat meows\n";
}
};

int main() {
Animal* animal1 = new Dog();
Animal* animal2 = new Cat();

animal1->sound(); // Calls Dog's sound method

animal2->sound(); // Calls Cat's sound method

delete animal1;
delete animal2;

return 0;
}

Explanation:

● In this example, the sound() function in the Animal base class is declared as
virtual, which allows derived classes (Dog and Cat) to override this function.
● The overridden sound() function in the derived classes is invoked through pointers to
the base class, demonstrating polymorphism.
● This mechanism enables the appropriate method to be called based on the actual object
type, rather than the pointer type.
36. Create a scenario where a C++ program handles a collection of objects
through a pointer to an abstract base class. Describe how polymorphism
allows the program to work with diverse derived objects using a single
interface.

Answer:

Code Example:

cpp
Copy code
#include <iostream>
#include <vector>
using namespace std;

class Shape {
public:
virtual void draw() const = 0; // Pure virtual function
};

class Circle : public Shape {

public:
void draw() const override {
cout << "Drawing a Circle\n";
}
};

class Rectangle : public Shape {

public:
void draw() const override {
cout << "Drawing a Rectangle\n";
}
};

int main() {
vector<Shape*> shapes;

shapes.push_back(new Circle());
shapes.push_back(new Rectangle());
 for (Shape* shape : shapes) {
shape->draw(); // Polymorphism in action: correct method
called based on actual object type
}

// Clean up
for (Shape* shape : shapes) {
delete shape;
}

return 0;
}

Explanation:

● The abstract base class Shape has a pure virtual function draw(), which is overridden
by the derived classes Circle and Rectangle.
● The shapes vector stores pointers to Shape, allowing the program to handle diverse
derived objects (Circle, Rectangle) in a unified way.
● Polymorphism allows the program to call the correct draw() method based on the
actual object type, even when working with pointers to the base class.

37. Discuss the role of interfaces in C++ using abstract base classes.
Explain how interfaces are created, and provide an example of
implementing an interface in a C++ program.

Answer:

Explanation:

● In C++, an interface is typically implemented using an abstract base class with only pure
virtual functions. These classes cannot be instantiated directly but define a contract that
derived classes must follow.
● Abstract base classes with only pure virtual functions act as interfaces, defining common
behavior for derived classes.

Code Example:

cpp
Copy code
#include <iostream>
using namespace std;

class Drawable {
public:
virtual void draw() const = 0; // Pure virtual function
(interface method)
virtual ~Drawable() = default; // Virtual destructor
};

class Circle : public Drawable {

public:
void draw() const override {
cout << "Drawing a Circle\n";
}
};

class Rectangle : public Drawable {

public:
void draw() const override {
cout << "Drawing a Rectangle\n";
}
};

int main() {
Drawable* drawable1 = new Circle();
Drawable* drawable2 = new Rectangle();

drawable1->draw(); // Calls Circle's draw method

drawable2->draw(); // Calls Rectangle's draw method

delete drawable1;
delete drawable2;

return 0;
}

Explanation:
 ● Drawable is an interface defined by the pure virtual method draw(). Both Circle and
Rectangle implement this interface by providing their own versions of draw().
● This allows you to treat different shapes as Drawable objects and work with them
polymorphically.

38. Create a program that models a shape hierarchy with an abstract base
class Shape and derived classes like Circle and Rectangle. Implement
pure virtual functions for calculating area and perimeter. Demonstrate
polymorphism by calculating and displaying the area of various shapes.

Answer:

Code Example:

cpp
Copy code
#include <iostream>
#include <cmath>
using namespace std;

class Shape {
public:
virtual double area() const = 0; // Pure virtual function
for area
virtual double perimeter() const = 0; // Pure virtual function
for perimeter
virtual ~Shape() = default; // Virtual destructor
};

class Circle : public Shape {

double radius;
public:
Circle(double r) : radius(r) {}

double area() const override {

return M_PI * radius * radius;
}
 double perimeter() const override {
return 2 * M_PI * radius;
}
};

class Rectangle : public Shape {

double length, width;
public:
Rectangle(double l, double w) : length(l), width(w) {}

double area() const override {

return length * width;
}

double perimeter() const override {

return 2 * (length + width);
}
};

int main() {
Shape* shapes[2];
shapes[0] = new Circle(5.0);
shapes[1] = new Rectangle(4.0, 6.0);

for (int i = 0; i < 2; ++i) {

cout << "Area: " << shapes[i]->area() << ", Perimeter: " <<
shapes[i]->perimeter() << endl;
delete shapes[i]; // Clean up
}

return 0;
}

Explanation:

● The base class Shape has pure virtual functions area() and perimeter(), which
must be implemented by derived classes Circle and Rectangle.
● Each derived class provides its own implementation of area() and perimeter().
 ● Polymorphism allows the program to handle different shapes in a unified way, and the
correct function is called based on the actual object type.

39. Discuss the advantages of using polymorphism and virtual functions in

a C++ program. How can they lead to more maintainable and extensible
code? Provide a real-world scenario to illustrate these benefits.

Answer:

Explanation:

● Polymorphism and virtual functions allow C++ programs to handle objects of different
types in a uniform manner. This means you can write code that works with a base class
type while allowing derived classes to provide their specific behavior.
● Advantages:
1. Maintainability: The code can be more easily modified and extended without
altering the base structure.
2. Extensibility: New classes can be added without changing existing code. You
can simply derive new classes from the base class and override methods as
needed.
3. Code Reusability: Common functionality can be written in the base class, and
specific behavior can be customized in the derived classes.

Real-World Scenario:

● In a graphics application, you may have a Shape base class and several derived classes
such as Circle, Rectangle, and Triangle. Using polymorphism, you can manage
all shapes using a pointer to the Shape class and call the appropriate draw() method
for each shape type without knowing its exact type at compile time. This makes it easier
to add new shapes (like Ellipse) in the future.

40. Describe the purpose and functionality of virtual functions in C++. How
do they facilitate dynamic binding? Provide a code example that illustrates
the use of virtual functions.

Answer:

Explanation:

● Virtual functions in C++ allow for dynamic (or late) binding, meaning that the function
call is resolved at runtime based on the actual object type, rather than the type of the
pointer or reference that is used to call the function.
 ● This is crucial for achieving polymorphism, as it allows derived classes to override
functions of the base class and ensures that the correct function is called according to
the actual object type.

Code Example:

cpp
Copy code
#include <iostream>
using namespace std;

class Base {
public:
virtual void show() { // Virtual function
cout << "Base class\n";
}
};

class Derived : public Base {

public:
void show() override { // Override the base class function
cout << "Derived class\n";
}
};

int main() {
Base* basePtr;
Derived derivedObj;

basePtr = &derivedObj;
basePtr->show(); // Dynamic binding occurs here, calling
Derived's show()

return 0;
}

Explanation:

● The show() function is declared as virtual in the base class.

 ● At runtime, when basePtr->show() is called, it uses the Derived class's show()
method, even though basePtr is of type Base*. This is dynamic binding in action,
which resolves to the correct function according to the actual object type (Derived).

41. Discuss the difference between early binding and late binding in the
context of virtual functions and polymorphism. Provide an example
illustrating both types of binding.

Answer:

Explanation:

● Early binding (Static Binding): The function to be called is determined at compile time
based on the type of the pointer or reference.
● Late binding (Dynamic Binding): The function to be called is determined at runtime
based on the actual object type, which is made possible by using virtual functions.

Code Example (Early Binding):

cpp
Copy code
#include <iostream>
using namespace std;

class Base {
public:
void show() { // Non-virtual function
cout << "Base class\n";
}
};

class Derived : public Base {

public:
void show() {
cout << "Derived class\n";
}
};

int main() {
Base baseObj;
 Derived derivedObj;
Base* basePtr;

basePtr = &baseObj;
basePtr->show(); // Early binding, calls Base's show()

basePtr = &derivedObj;
basePtr->show(); // Early binding, calls Base's show(), not
Derived's

return 0;
}

Explanation:

● In this example, show() is not virtual, so function calls are bound at compile time,
resulting in early binding. Even though basePtr points to a Derived object, the
function from Base is called because the function is not virtual.

Code Example (Late Binding):

cpp
Copy code
#include <iostream>
using namespace std;

class Base {
public:
virtual void show() { // Virtual function
cout << "Base class\n";
}
};

class Derived : public Base {

public:
void show() override { // Override the base class function
cout << "Derived class\n";
}
};
int main() {
Base baseObj;
Derived derivedObj;
Base* basePtr;

basePtr = &baseObj;
basePtr->show(); // Late binding, calls Base's show()

basePtr = &derivedObj;
basePtr->show(); // Late binding, calls Derived's show()

return 0;
}

Explanation:

● Since show() is virtual, the correct function is called based on the actual object type,
even though basePtr is of type Base*. This is late binding (dynamic binding).

42. Provide a comparison of early and late binding in terms of code

maintainability, flexibility, and extensibility. Discuss how each binding type
impacts software development and evolution.

Answer:

Comparison:

● Early Binding (Static Binding):

○ Code Maintainability: Early binding is straightforward and faster, but it may
become rigid when the program grows. Any changes to function behavior require
modifying existing code, which can increase maintenance efforts.
○ Flexibility: It is less flexible because the function behavior is fixed at compile
time. Adding new types that behave differently requires changes to the code.
○ Extensibility: Early binding makes extending the code more challenging, as new
types and behaviors must be added explicitly by altering the existing code.
○ Impact on Software Development: Early binding leads to tightly coupled
systems where changes in one part of the system may require significant
refactoring of other parts.
 ● Late Binding (Dynamic Binding):
○ Code Maintainability: Late binding improves maintainability by making the code
more modular. New types and behaviors can be added without changing existing
code, leading to less frequent changes and easier maintenance.
○ Flexibility: Late binding allows greater flexibility, as the exact method to call is
determined at runtime, enabling polymorphism. It is easier to introduce new
behavior without altering existing code.
○ Extensibility: Late binding facilitates extensibility by allowing new derived
classes to be added without modifying the base class or existing classes. This
promotes cleaner and more scalable designs.
○ Impact on Software Development: Late binding allows for more loosely
coupled systems, enabling developers to build and extend systems incrementally.
However, it may introduce slight performance overhead due to runtime resolution
of method calls.

43. Discuss the implications of changing the binding type from late binding
to early binding or vice versa in an existing software system. Describe the
challenges and considerations involved in such a transition.

Answer:

Implications of Changing Binding Type:

1. Changing from Late Binding to Early Binding (Virtual to Non-Virtual):

○ Challenges:
■ Loss of polymorphism: The ability to dynamically resolve function calls
based on the object type will be removed.
■ Code Changes: Any class hierarchy relying on late binding (virtual
functions) will break, and significant changes may be needed to maintain
functionality.
■ Maintenance Issues: Code will become more tightly coupled, making it
harder to extend or modify the system later.
○ Considerations:
■ Performance: Early binding can improve performance since function calls
are resolved at compile time.
■ Simplified Debugging: Early binding can make debugging easier since
there is no runtime resolution of method calls.
2. Changing from Early Binding to Late Binding (Non-Virtual to Virtual):
○ Challenges:
■ Performance Overhead: Using virtual functions introduces a slight
performance penalty due to the need for runtime method resolution.
 ■ Code Modifications: All base class methods must be explicitly marked as
virtual, and derived classes may need to override these methods.
○ Considerations:
■ Flexibility: The system will become more flexible, supporting
polymorphism and enabling easier extension with new derived classes.
■ Complexity: The system will become more complex as late binding adds
dynamic behavior, and developers must be mindful of the implications of
using virtual functions.

44. Describe how dynamic polymorphism and virtual functions relate to late
binding in C++. Provide an example that showcases the use of virtual
functions and late binding.

Answer:

Explanation:

● Dynamic Polymorphism refers to the ability of a program to select the correct method
for an object at runtime, based on the actual object type, not the pointer or reference
type.
● This is achieved using virtual functions in C++, where the function to call is determined
dynamically at runtime (late binding), enabling the system to choose the appropriate
method from a hierarchy of classes.

Code Example:

cpp
Copy code
#include <iostream>
using namespace std;

class Animal {
public:
virtual void speak() const { // Virtual function
cout << "Animal speaks\n";
}
};

class Dog : public Animal {

public:
void speak() const override { // Overriding the virtual function
 cout << "Dog barks\n";
}
};

class Cat : public Animal {

public:
void speak() const override { // Overriding the virtual function
cout << "Cat meows\n";
}
};

int main() {
Animal* animal1 = new Dog();
Animal* animal2 = new Cat();

animal1->speak(); // Late binding, calls Dog's speak()

animal2->speak(); // Late binding, calls Cat's speak()

delete animal1;
delete animal2;

return 0;
}

Explanation:

● The speak() function is declared as virtual in the base class Animal. When
animal1->speak() or animal2->speak() is called, the function call is resolved at
runtime (late binding), and the correct speak() method from Dog or Cat is invoked,
based on the actual object type.