Qn- Overload the "addition" operator for the string so that it adds two strings and return the

result.

#include <iostream>
#include <string>
std::string operator+(const std::string& str1, const std::string& str2) {
return str1 + str2;
}
int main() {
std::string str1 = "Hello, ";
std::string str2 = "world!";
std::string result = str1 + str2; // Overloaded operator
std::cout << "Concatenated string: " << result << std::endl;
return 0;
}
In this example, we overload the + operator directly for std::string. The overloaded operator takes
two std::string objects as parameters and returns their concatenation.
This approach is simpler and more concise than creating a custom class to overload the operator.
You can use it to concatenate std::string objects more naturally.
Q3- What is a virtual functions and a pure virtual function? How is dynamic binding
implemented with virtual functions? Explain the rules to write and use it
Solution: Virtual functions and pure virtual functions are concepts in object-oriented
programming, primarily associated with C++ and similar languages.
1. Virtual Functions:
- A virtual function is a member function of a base class that can be overridden by derived
classes.
- It enables polymorphism, allowing different derived classes to provide their own
implementations of the same function.
- When a virtual function is called on a base class pointer or reference, the appropriate derived
class's version of that function is executed, based on the actual object type at runtime.
- In C++, you declare a function as virtual by using the `virtual` keyword in the base class, like this
class Base {
public:
 virtual void someFunction() {
// Base class implementation
}
};
```

2. **Pure Virtual Functions**:

- A pure virtual function is a virtual function declared in a base class without providing any
implementation in the base class itself.
- It's declared with `= 0` at the end of the function declaration, indicating that derived classes
must provide an implementation.
- A class containing one or more pure virtual functions is called an abstract base class, and you
cannot create instances of it.
- Pure virtual functions are used to define an interface that derived classes must adhere to.
Example
class Base {
public:
virtual void someFunction() = 0; // Pure virtual function
};
Dynamic Binding:
- Dynamic binding (also known as late binding or runtime polymorphism) is a mechanism in object-
oriented programming that allows the selection of the appropriate function implementation to be
determined at runtime, rather than at compile time.
- It is achieved through virtual functions. When you call a virtual function on a base class pointer or
reference, the actual function implementation is determined based on the object's runtime type.
- Dynamic binding is a fundamental concept for achieving polymorphism, where objects of
different classes can be treated uniformly through a common interface.
Rules for Writing and Using Virtual Functions:
- To use virtual functions and dynamic binding effectively, follow these rules:
1. Declare a function as `virtual` in the base class if it's intended to be overridden by derived
classes.
2. Derive classes from the base class and provide implementations for the virtual functions you
want to override.
 3. Call virtual functions through base class pointers or references to enable dynamic binding. This
allows you to treat objects of different derived classes uniformly.
4. The base class's virtual function implementation can be provided but is optional. If you provide
a base class implementation, it can be called explicitly from derived classes using the scope
resolution operator (`::`).
5. If a class has pure virtual functions, it becomes an abstract class, and you cannot create
instances of it. It serves as a blueprint for derived classes.
Here's a simple example to illustrate dynamic binding with virtual functions in C++:
#include <iostream>
class Base {
public:
virtual void someFunction() {
std::cout << "Base class implementation" << std::endl;
}
};
class Derived : public Base {
public:
void someFunction() override {
std::cout << "Derived class implementation" << std::endl;
}
};
int main() {
Base* ptr = new Derived; // Base class pointer pointing to a Derived object
ptr->someFunction(); // Dynamic binding selects the Derived class implementation

delete ptr;
return 0;
}
In this example, we have a base class `Base` with a virtual function `someFunction`. We create a
derived class `Derived` that overrides this function. By using dynamic binding, the `someFunction`
implementation from the derived class is called when we use a base class pointer to a derived class
object.
Ques 4:What are the advantage of operator overloading in C++? What is it's syntax and
rules? Describe operator overloading with the help of a suitable example.
Operator overloading in C++ allows you to define how operators work for user-defined types (e.g.,
classes) just like they work for built-in types (e.g., integers). It makes your code more intuitive and
expressive by allowing you to use operators in a way that is natural for your custom types.
The syntax and rules for operator overloading are as follows:
Syntax for Operator Overloading:
Operator overloading can be done by defining a member function or a global function for the operator.
The syntax for overloading an operator depends on whether you are defining it as a member function
or a global function.
return_type operator@(const YourType& other) {
// Define how the @ operator works for YourType
// You can access the current object using 'this' and the other object using 'other'
// Return the result of the operation
}
The advantages of operator overloading include:
Clarity and Readability: Operator overloading can make your code more intuitive and easier to read
by allowing you to use familiar operators for custom data types. For example, you can use + to
concatenate strings or add complex numbers, which makes the code more readable.
Reusability: By defining operators for your custom types, you can reuse existing code and algorithms
for your classes. For example, you can use standard algorithms like sort with custom data types.
Abstraction: Operator overloading can provide a higher level of abstraction, allowing you to work
with complex data types in a way that hides the underlying implementation details.
Standard Library Compatibility: You can make your custom types work seamlessly with standard
library algorithms and containers, improving code integration.
Uniform Interface: Operator overloading can provide a uniform interface for custom types, making
it easier to work with different data structures consistently.
Consistency: It helps maintain consistency when working with different types of data, as you can use
the same operators for various types.
Enhanced Flexibility: You can define how operators work for your classes, which is especially
valuable for domain-specific or specialized operations.
Reduced Error Prone: Well-designed operator overloads can help reduce the risk of errors by
providing a clear and intuitive way to work with custom types.
Improved Documentation: Code that uses operator overloading can be self-documenting, as it
follows standard mathematical notation and expectations.
EXAMPLE
#include <iostream>
class Point {
private:
int x;
int y;
public:
Point(int a, int b) : x(a), y(b) {}
// Overload the + operator to add two Point objects
Point operator+(const Point& other) {
int sumX = x + other.x;
int sumY = y + other.y;
return Point(sumX, sumY);
}
// Overload the << operator to display Point objects
friend std::ostream& operator<<(std::ostream& out, const Point& p);
};
// Overload the << operator as a global function
std::ostream& operator<<(std::ostream& out, const Point& p) {
out << "(" << p.x << ", " << p.y << ")";
return out;
}
int main() {
Point p1(2, 3);
Point p2(1, 4);
Point p3 = p1 + p2; // Use the overloaded + operator
std::cout << "p1: " << p1 << std::endl;
std::cout << "p2: " << p2 << std::endl;
std::cout << "p1 + p2: " << p3 << std::endl;
return 0;
}

OUTPUT: p1: (2, 3)

p2: (1, 4)
p1 + p2: (3, 7)

Q5- (a) Explain the need of virtual destructor with an example.

(b) What is polymorphism. Distinguish between early and late binding
Solution 5(a): The need for a virtual destructor arises when you have a class hierarchy with
inheritance, and you want to ensure that the destructors of derived classes are called properly
when an object of a derived class is deleted through a pointer to its base class. Without a virtual
destructor, you may encounter problems with resource management and memory leaks.
Example:
#include <iostream>
class Base {

public:

Base() {

std::cout << "Base constructor" << std::endl;

virtual ~Base() {

std::cout << "Base destructor" << std::endl;

};

class Derived : public Base {

public:

Derived() {

std::cout << "Derived constructor" << std::endl;

~Derived() {

std::cout << "Derived destructor" << std::endl;

};

int main() {

Base* basePtr = new Derived();

 delete basePtr;

return 0;

Sol 5(b) Polymorphism is a fundamental concept in object-oriented programming (OOP) that allows objects of
different classes to be treated as objects of a common base class. It enables you to write more generic and flexible
code by allowing objects to respond to the same method or function call in a way that is appropriate for their specific
class. Polymorphism is closely related to inheritance and is a key feature of OOP.

There are two main types of polymorphism:

Compile-time (Static) Polymorphism (Early Binding):

Also known as early binding, this type of polymorphism occurs at compile time.

It is based on the function or method overloading, which means having multiple functions with the same name in a
single class.

The appropriate function or method to be called is determined at compile time based on the number and types of
arguments provided to the function.

It is resolved during the compilation phase.

Examples include function overloading and operator overloading.

Example of early binding (function overloading):

int add(int a, int b) {

return a + b;

double add(double a, double b) {

return a + b;

Run-time (Dynamic) Polymorphism (Late Binding):

Also known as late binding, this type of polymorphism occurs at runtime.

It is based on inheritance and the use of virtual functions.

It allows objects of derived classes to be treated as objects of the base class, and the actual function called is
determined at runtime based on the type of the object.

Late binding is achieved through the use of virtual functions and function pointers (or function references).

It is a fundamental feature of OOP and is particularly useful for achieving a higher level of abstraction and code
reusability.

Example of late binding (using virtual functions):

class Base {

public:

virtual void display() {

std::cout << "Display from Base" << std::endl;

}
};

class Derived : public Base {

public:

void display() override {

std::cout << "Display from Derived" << std::endl;

};

int main() {

Base* ptr;

Derived obj;

ptr = &obj;

ptr->display(); // Late binding, calls Derived's display

return 0;

In the late binding example, the display function is marked as virtual, and when it is called on a pointer to the base
class that actually points to an object of the derived class, the correct implementation of display in the derived class
is called at runtime. This is a key feature of polymorphism in C++ and allows for dynamic and flexible behavior in your
code

Q1- When do we make a virtual function "pure"? What are the implications of making pure
virtual a function? Explain.
Solution : In C++, a virtual function is made "pure" by using the `= 0` syntax in its declaration within
an abstract base class. A pure virtual function is a function that is declared in a base class but has
no implementation in that class. It is meant to be overridden by derived classes, and any derived
class that does not provide an implementation for the pure virtual function will also be considered
an abstract class. Abstract classes cannot be instantiated, and their main purpose is to serve as a
blueprint for other classes.
Here's how you declare a pure virtual function:
class Base {
public:
virtual void pureVirtualFunction() = 0;
};
Implications of making a function pure virtual:
1. Abstract Class: When a class contains at least one pure virtual function, it becomes an abstract
class. Abstract classes cannot be instantiated, which means you cannot create objects of such a
class. They serve as a blueprint for derived classes.
2. Subclass Responsibility: Any class that derives from an abstract class with pure virtual functions
must provide concrete (implemented) versions of these functions. Failure to do so will result in a
compilation error, making it mandatory for subclasses to implement these methods.
3. Polymorphism: Pure virtual functions are an essential part of achieving polymorphism in C++.
They allow you to define a common interface in the base class while letting derived classes provide
specific implementations. This enables you to work with objects of different derived classes
through a pointer or reference to the base class, invoking the appropriate overridden method.
4. Design Pattern: Pure virtual functions are commonly used in design patterns like the "Template
Method" and "Factory Method" patterns to provide a skeletal structure for classes and allow for
customization of behavior in derived classes.
5. Flexibility and Extensibility: By defining a common interface with pure virtual functions in an
abstract base class, you make it easier to extend your code by adding new derived classes that
adhere to the same interface. This promotes code reusability and maintainability.
In summary, making a function pure virtual in C++ is a way to create an abstract base class, defining
a contract that derived classes must adhere to by providing concrete implementations. This
concept is fundamental to object-oriented programming and is used to achieve polymorphism,
promote code organization, and ensure consistency in the behavior of related classes.