Unit 5
Q. What is meant by Inheritance? What are diffferent
types of Inheritance? Explain Multilevel inheritance
with an example.
Inheritance
Inheritance is a fundamental concept in object-oriented programming that allows a new class
to inherit properties and behaviors from an existing class. The existing class is referred to as
the base class or parent class, and the new class is known as the derived class or child class.
Inheritance facilitates code reusability and establishes a hierarchical relationship between
classes.
Types of Inheritance
There are several types of inheritance, each serving different purposes:
1. Single Inheritance: In single inheritance, a derived class inherits from only one base
class. This is the simplest form of inheritance.
2. Multiple Inheritance: Multiple inheritance occurs when a derived class inherits from
more than one base class. While it can be powerful, multiple inheritance can lead to
complexities and ambiguities in the code.
3. Multilevel Inheritance: Multilevel inheritance involves a chain of inheritance where
a derived class serves as the base class for another class. This creates a hierarchical
structure with multiple levels of inheritance.
4. Hierarchical Inheritance: In hierarchical inheritance, multiple classes are derived
from a single base class. This results in a tree-like structure with one base class and
multiple derived classes.
5. Hybrid Inheritance: Hybrid inheritance is a combination of two or more types of
inheritance. It can be achieved through various combinations such as multiple and
multilevel inheritance.
Multilevel Inheritance
Multilevel inheritance involves the creation of a chain of classes where each derived class
inherits from its immediate parent, which in turn inherits from its own parent, and so on. This
creates a hierarchical structure with multiple levels of inheritance.
Example of Multilevel Inheritance
Consider the following example to illustrate multilevel inheritance:
class Animal:
def speak(self):
print("Animal speaks")
class Dog(Animal):
def bark(self):
print("Dog barks")
Unit 5
class Labrador(Dog):
def color(self):
print("Labrador is golden")
In this example, the Animal class serves as the base class for the Dog class, which in turn
serves as the base class for the Labrador class. The Labrador class inherits both the speak
method from Animal and the bark method from Dog, creating a multilevel inheritance
hierarchy.
Unit 5
Q. What ‘this’ pointer? Give example.
Here's a summary of the "this" pointer in C++ in seven points:
1. Purpose: The "this" pointer is a special keyword in C++ that refers to the
current object of the class. It allows member functions to access the data
members of the object they are called on.
2. Implicit Parameter: The "this" pointer is an implicit parameter of all non-static
member functions. It is not necessary to explicitly declare or pass the "this"
pointer to the function.
3. Type: The type of the "this" pointer is the same as the type of the class to
which it belongs. For example, in a class named "Point," the "this" pointer
would have the type "Point*."
4. Const or Volatile Qualifier: The "this" pointer can be modified by the "const" or
"volatile" keywords to indicate the mutability of the object it points to. For
instance, a "const this" pointer indicates that the object cannot be modified
within the member function.
5. Static Member Functions: Static member functions do not have a "this" pointer
because they operate on the class itself rather than a specific object.
6. Accessing Data Members: To access data members of the current object
using the "this" pointer, use the arrow operator (->) or the dot operator (.). For
example, to access the "x" member of the current object, you could use this-
>x or (*this).x.
7. Ownership: The "this" pointer is not owned by the programmer and cannot be
reassigned. It is managed by the compiler and remains valid throughout the
execution of the member function.
Sure, here's an example of how to use the "this" pointer in C++:
C++
class Point {
public:
int x;
int y;
Point(int x, int y) {
this->x = x; // Using 'this' to access the current object's 'x'
member
this->y = y; // Using 'this' to access the current object's 'y'
member
}
Unit 5
void print() {
std::cout << "x: " << this->x << ", y: " << this->y << std::endl;
}
};
int main() {
Point point(10, 20);
point.print(); // Output: x: 10, y: 20
}
In this example, the "this" pointer is used within the constructor and the "print"
member function to access the data members of the current object. The "this" pointer
allows member functions to work with the specific object they are called on without
having to explicitly pass the object as an argument.
Unit 5
Q. Explain any two with example.
i)Exception Handling
ii)Virtual and Pure Function
iii)Operator Overloading
Exception handling is a crucial mechanism in C++ that enables programmers to
gracefully deal with unexpected errors or exceptional circumstances during program
execution. It provides a structured approach to identify, handle, and recover from
errors, preventing the program from crashing abruptly.
The three primary keywords involved in exception handling are:
1. try: The try block identifies a code segment that may potentially generate an
exception.
2. throw: The throw keyword is used to signal the occurrence of an exception. It
raises the exception and transfers control to the appropriate exception
handler.
3. catch: The catch block specifies the code that should be executed when an
exception of a particular type is thrown. It handles the exception and provides
a means to recover from the error.
To illustrate the concept of exception handling, consider the following example:
C++
#include <iostream>
int main() {
int num1, num2;
try {
std::cout << "Enter the first number: ";
std::cin >> num1;
std::cout << "Enter the second number: ";
std::cin >> num2;
if (num2 == 0) {
throw std::invalid_argument("Division by zero");
}
int result = num1 / num2;
std::cout << "Division result: " << result << std::endl;
} catch (std::invalid_argument& e) {
std::cerr << "Error: " << e.what() << std::endl;
Unit 5
}
return 0;
}
In this example, the try block encloses the code that may potentially generate an
exception – division by zero. The throw keyword is used within the try block to
signal an exception if the divisor is zero. The catch block, specifically designed to
handle std::invalid_argument exceptions, catches the thrown exception and
displays an appropriate error message.
This example demonstrates how exception handling allows the program to recover
from an error and continue execution instead of abruptly terminating.
----------------------------------------------------------------------------------------------------------------
Sure, here is an explanation of virtual and pure functions in C++ with examples:
Virtual Functions
A virtual function is a member function of a base class that can be redefined by
derived classes. This allows for polymorphism, which is the ability of objects of
different classes to respond to the same message (i.e., function call) in different
ways.
To declare a virtual function, you simply add the virtual keyword to the function
declaration in the base class. For example, the following code declares a virtual
function called make_sound() in the Animal base class:
C++
class Animal {
public:
virtual void make_sound() = 0;
};
This means that all derived classes of Animal must provide their own implementation
of the make_sound() function. For example, the following code defines two derived
classes of Animal called Dog and Cat, and each class provides its own
implementation of the make_sound() function:
C++
class Dog: public Animal {
public:
void make_sound() override {
std::cout << "Woof!" << std::endl;
}
};
class Cat: public Animal {
public:
void make_sound() override {
std::cout << "Meow!" << std::endl;
}
Unit 5
};
Now, when you call the make_sound() function on an object of a derived class, the
overridden implementation of the function in the derived class will be called. For
example, the following code creates objects of Dog and Cat and calls the
make_sound() function on each object:
C++
Dog dog;
Cat cat;
dog.make_sound(); // Prints "Woof!"
cat.make_sound(); // Prints "Meow!"
Pure Virtual Functions
A pure virtual function is a virtual function that does not have an implementation in
the base class. It is declared by adding the = 0 suffix to the function declaration.
Classes that contain pure virtual functions are called abstract classes. Abstract
classes cannot be instantiated, but they can be used as base classes for derived
classes that provide implementations of the pure virtual functions.
Pure virtual functions are used to define the interface for a class hierarchy. They
specify the behavior that all derived classes must implement, but they do not provide
a concrete implementation of that behavior. This allows for polymorphism, as derived
classes can provide different implementations of the pure virtual functions.
For example, the following code declares a pure virtual function called
calculate_area() in the Shape base class:
C++
class Shape {
public:
virtual double calculate_area() = 0;
};
This means that all derived classes of Shape must provide their own implementation
of the calculate_area() function. For example, the following code defines two
derived classes of Shape called Circle and Rectangle, and each class provides its
own implementation of the calculate_area() function:
C++
class Circle: public Shape {
public:
Circle(double radius) : radius(radius) {}
double get_radius() const { return radius; }
double calculate_area() override {
return M_PI * radius * radius;
}
private:
Unit 5
double radius;
};
class Rectangle: public Shape {
public:
Rectangle(double width, double height) : width(width),
height(height) {}
double get_width() const { return width; }
double get_height() const { return height; }
double calculate_area() override {
return width * height;
}
private:
double width;
double height;
};
Now, when you call the calculate_area() function on an object of a derived class,
the overridden implementation of the function in the derived class will be called. For
example, the following code creates objects of Circle and Rectangle and calls the
calculate_area() function on each object:
C++
Circle circle(5.0);
Rectangle rectangle(3.0, 4.0);
std::cout << "Circle area: " << circle.calculate_area() << std::endl;
// Prints "78.5398"
std::cout << "Rectangle area: " << rectangle.calculate_area() <<
std::endl; // Prints "12.0"
I hope this explanation is helpful. Please let me know if you have any other
questions.
----------------------------------------------------------------------------------------------------------------
Operator overloading is a feature of C++ that allows programmers to redefine the
meaning of operators for user-defined types. This means that you can use the same
operator to perform different operations depending on the data types it is applied to.
For example, you can overload the + operator to add two Complex numbers, or to
concatenate two strings.
Here is an example of how to overload the + operator to add two Complex numbers:
C++
class Complex {
private:
double real;
double imag;
Unit 5
public:
Complex(double real, double imag) {
this->real = real;
this->imag = imag;
}
Complex operator+(const Complex& other) {
return Complex(this->real + other.real, this->imag + other.imag);
}
};
With this code, you can add two Complex numbers using the + operator:
C++
Complex a(1, 2);
Complex b(3, 4);
Complex c = a + b;
Here is an example of how to overload the + operator to concatenate two strings:
C++
class String {
private:
char* data;
int length;
public:
String(const char* data) {
this->length = strlen(data);
this->data = new char[this->length + 1];
strcpy(this->data, data);
}
~String() {
delete[] data;
}
String operator+(const String& other) {
char* newData = new char[this->length + other.length + 1];
strcpy(newData, this->data);
strcat(newData, other.data);
return String(newData);
}
};
With this code, you can concatenate two strings using the + operator:
C++
String a("Hello, ");
String b("world!");
String c = a + b;
Unit 5
Operator overloading can be a powerful tool for making your code more readable
and expressive. However, it is important to use it with care, as it can also make your
code more difficult to understand and debug.
Unit 5
Q. Define Operator Overloading. Explain how to
overload unary and binary operators in C++?
Operator Overloading
In C++, operator overloading allows you to redefine the way operators work with user-
defined types. This means that you can make operators such as +, -, *, /, etc., work with your
custom classes. Operator overloading is a powerful feature of C++ that provides flexibility
and expressiveness to the language.
Overloading Unary Operators
Unary operators are those that operate on a single operand. To overload unary operators in
C++, you need to define member functions for the class that represent the unary operator. For
example, if you want to overload the unary minus (-) operator for a class, you would define a
member function with the following signature:
return_type operator-();
Here, return_type is the type of the value returned by the operator. Inside this member
function, you can define the behavior of the unary minus operator for your class.
Overloading Binary Operators
Binary operators are those that operate on two operands. To overload binary operators in
C++, you need to define member functions for the class that represent the binary operator.
For example, if you want to overload the addition (+) operator for a class, you would define a
member function with the following signature:
return_type operator+(const YourClass& other);
Here, return_type is the type of the value returned by the operator, and YourClass is the
type of the operand being added. Inside this member function, you can define the behavior of
the addition operator for your class.
When overloading binary operators, it’s important to consider whether to overload them as
member functions or global functions. Member function overloads have an implicit left-hand
operand (the object on which they are called), while global function overloads require both
operands to be explicitly specified.
In both cases of overloading unary and binary operators, it’s crucial to ensure that the
overloaded operators maintain logical consistency and adhere to expected behavior to avoid
confusion for users of your classes.
Unit 5
Q. Overload an operator ‘+’ to add two ages defined
with years, months and days.
Operator Overloading in C++
In C++, operator overloading allows us to define the way an operator works for user-defined
types. To overload the ‘+’ operator to add two ages defined with years, months, and days, we
can create a class to represent the age and then overload the ‘+’ operator to perform the
addition operation.
Here’s an example of how this can be achieved:
#include
class Age {
private:
int years;
int months;
int days;
public:
Age(int y, int m, int d) : years(y), months(m), days(d) {}
Age operator+(const Age& other) {
int totalYears = years + other.years;
int totalMonths = months + other.months;
int totalDays = days + other.days;
if (totalMonths >= 12) {
totalYears += totalMonths / 12;
totalMonths %= 12;
}
if (totalDays >= 30) {
totalMonths += totalDays / 30;
totalDays %= 30;
}
return Age(totalYears, totalMonths, totalDays);
}
void display() {
std::cout << "Years: " << years << ", Months: " << months << ",
Days: " << days << std::endl;
}
};
int main() {
Age age1(25, 6, 15);
Age age2(30, 4, 20);
Age totalAge = age1 + age2;
Unit 5
std::cout << "Total Age: ";
totalAge.display();
return 0;
}
In this example, we have created a class Age with three private member variables
representing years, months, and days. We have overloaded the ‘+’ operator using a member
function to perform the addition of two Age objects. Inside the overloaded ‘+’ operator
function, we perform the addition of years, months, and days while taking care of carrying
over excess months to years and excess days to months.
When we run the main function, it creates two Age objects age1 and age2, adds them
together using the overloaded ‘+’ operator, and displays the total age.
Unit 5
Q. Explain different types of inheritance. Illustrate each
type.
According to www.iAsk.ai Ask Ai Search Engine:
Types of Inheritance in C++
In C++, inheritance is a key feature that allows a class to inherit properties and behaviors
from another class. There are several types of inheritance in C++, each with its own
characteristics and usage. The main types of inheritance in C++ are:
1. Single Inheritance: Single inheritance involves a derived class inheriting from only
one base class. This is the most common type of inheritance. The syntax for single
inheritance in C++ is as follows:
2. class Base {
3. // Base class members and methods
4. };
5.
6. class Derived : public Base {
7. // Derived class members and methods
};
In this example, the Derived class inherits from the Base class.
8. Multiple Inheritance: Multiple inheritance allows a derived class to inherit from
multiple base classes. The syntax for multiple inheritance in C++ is as follows:
9. class Base1 {
10. // Base1 class members and methods
11. };
12.
13. class Base2 {
14. // Base2 class members and methods
15. };
16.
17. class Derived : public Base1, public Base2 {
18. // Derived class members and methods
};
In this example, the Derived class inherits from both the Base1 and Base2 classes.
19. Multilevel Inheritance: Multilevel inheritance involves a chain of inheritance, where
a derived class serves as the base class for another derived class. The syntax for
multilevel inheritance in C++ is as follows:
20. class Base {
21. // Base class members and methods
22. };
23.
24. class Intermediate : public Base {
25. // Intermediate class members and methods
26. };
Unit 5
27.
28. class Derived : public Intermediate {
29. // Derived class members and methods
};
In this example, the Intermediate class serves as the base for the Derived class.
30. Hierarchical Inheritance: Hierarchical inheritance involves multiple derived classes
inheriting from a single base class. The syntax for hierarchical inheritance in C++ is
as follows:
31. class Base {
32. // Base class members and methods
33. };
34.
35. class Derived1 : public Base {
36. // Derived1 class members and methods
37. };
38.
39. class Derived2 : public Base {
40. // Derived2 class members and methods
};
In this example, both Derived1 and Derived2 classes inherit from the Base class.
41. Hybrid (Virtual) Inheritance: Hybrid or virtual inheritance is used to address the
“diamond problem” that arises in multiple inheritance scenarios where a derived class
indirectly inherits from a base more than once through different paths. Virtual
inheritance ensures that only one instance of the common base is inherited by the final
derived class. The syntax for virtual inheritance in C++ uses the virtual keyword:
42. class Base {
43. // Base class members and methods
44. };
45.
46. class Intermediate1 : virtual public Base {
47. // Intermediate1 class members and methods
48. };
49.
50. class Intermediate2 : virtual public Base {
51. // Intermediate2 class members and methods
52. };
53.
54. class Derived : public Intermediate1, public Intermediate2 {
55. // Derived class members and methods
};
In this example, virtual inheritance ensures that there is only one instance of Base
when Derived inherits from both Intermediate1 and Intermediate2.
Each type of inheritance has its own use cases, advantages, and considerations when
designing object-oriented systems in C++. Understanding these types of inheritance is crucial
for creating well-structured and maintainable code.
Unit 5
Q. What is the mechanism of virtual function. Also
discuss pure virtual function.
According to www.iAsk.ai Ask Ai Search Engine:
What is the mechanism of virtual functions in C++?
In C++, a virtual function is a member function of a class that can be overridden by a derived
class. The mechanism of virtual functions is based on the use of a pointer to a function table
that contains the addresses of the functions defined in the base class and its derived classes.
Here’s how it works:
1. Pointer to Function Table: When a class is defined with one or more virtual functions, a
pointer to a function table is created for that class. The function table contains the addresses
of all the virtual functions defined in the class and its derived classes.
2. Virtual Function Calls: When a virtual function is called on an object of a derived class, the
CPU uses the pointer to the function table to find the address of the overridden version of
the function in the derived class. If the function is not overridden, the CPU uses the address
of the function in the base class.
3. Overriding: When a derived class overrides a virtual function, it provides its own
implementation of the function. The override is stored in the function table as a new entry
with the address of the overridden function.
4. Polymorphism: The ability to call a virtual function and have it resolved to the correct
implementation based on the type of the object being called is called polymorphism.
Polymorphism is the key feature of virtual functions that allows for object-oriented
programming.
Pure Virtual Functions
A pure virtual function is a virtual function that has no implementation in the base class. It is
declared as a placeholder to force derived classes to provide an implementation. A pure
virtual function is declared using the virtual keyword followed by the function name and
parameters, and it must have a = 0 statement at the end.
Here are some key points about pure virtual functions:
1. No Implementation: A pure virtual function has no implementation in the base class. It is
intended to be overridden by derived classes.
2. Must be Declared Virtual: A pure virtual function must be declared as a virtual function
using the virtual keyword.
3. Must have a = 0 Statement: A pure virtual function must have a = 0 statement at the end
to indicate that it has no implementation.
4. Forces Derived Classes to Provide an Implementation: A pure virtual function forces derived
classes to provide an implementation, ensuring that the function is not left unimplemented.
Unit 5
In summary, virtual functions in C++ provide a way to define functions that can be
overridden by derived classes, allowing for polymorphism and object-oriented programming.
Pure virtual functions are used to ensure that derived classes provide an implementation for a
particular function.
