Module Overview:
In this module, we explore the core principles of Object-Oriented Programming (OOP) in C++, focusing on the concepts of classes and objects. These fundamental concepts allow developers to structure code in a way that is more modular, maintainable, and reusable. We will cover how to define classes, create objects, understand encapsulation, and work with constructors and destructors.
1. Introduction to Object-Oriented Programming (OOP)
- What is OOP?
- Object-Oriented Programming is a programming paradigm that uses “objects” to represent data and methods to manipulate that data.
- Key principles of OOP:
- Encapsulation: Bundling data and methods that operate on the data within a class.
- Inheritance: Creating new classes based on existing ones.
- Polymorphism: Allowing different objects to be treated as instances of the same class through shared methods.
- Abstraction: Hiding complex implementation details and exposing only the necessary parts.
- Benefits of OOP:
- Promotes code reusability, scalability, and ease of maintenance.
- Helps organize code in a logical and intuitive way by modeling real-world entities.
2. Introduction to Classes and Objects
- What is a Class?
- A class is a blueprint for creating objects. It defines the data and behavior that the objects created from the class will have.
Syntax for defining a class:
public:
// Data members (variables)
// Member functions (methods)
};
- What is an Object?
- An object is an instance of a class. It represents a real-world entity with state (data) and behavior (functions).
- Objects are created by using the class as a template.
Example:
public:
string brand;
int year;
void displayInfo() {
cout << brand << ” ” << year << endl;
}
};
Car myCar; // Creating an object
myCar.brand = “Toyota”; // Setting object properties
myCar.year = 2020;
myCar.displayInfo(); // Calling object method
3. Defining and Initializing Classes
- Class Definition:
- A class consists of data members (variables) and member functions (methods). These define the characteristics and behaviors of objects.
Example:
public:
string title;
string author;
int publicationYear;
void printDetails() {
cout << title << ” by ” << author << “, ” << publicationYear << endl;
}
};
- Creating Objects:
- Objects are created based on a class and can access its members.
Example:
myBook.title = “1984”;
myBook.author = “George Orwell”;
myBook.publicationYear = 1949;
myBook.printDetails();
4. Constructors and Destructors
- What is a Constructor?
- A constructor is a special member function that is automatically called when an object is created. It is used to initialize data members of the class.
Syntax:
public:
ClassName() {
// Initialization code
}
};
- Types of Constructors:
- Default Constructor: A constructor that takes no parameters and initializes objects with default values.
- Parameterized Constructor: A constructor that takes parameters to initialize objects with specific values.
Example:
public:
int length, width;
Rectangle() { // Default constructor
length = 5;
width = 5;
}
Rectangle(int l, int w) { // Parameterized constructor
length = l;
width = w;
}
};
Rectangle rect1; // Calls default constructor
Rectangle rect2(10, 20); // Calls parameterized constructor
- What is a Destructor?
- A destructor is a special member function called when an object goes out of scope or is explicitly deleted. It is used to perform cleanup tasks like freeing dynamically allocated memory.
Syntax:
public:
~ClassName() {
// Cleanup code
}
};
Example:
public:
Student() {
cout << “Student object created” << endl;
}
~Student() {
cout << “Student object destroyed” << endl;
}
};
5. Access Modifiers
- What are Access Modifiers?
- Access modifiers define the visibility of class members (data and functions) to other parts of the program.
- Three types of access modifiers in C++:
- Public: Members are accessible from anywhere in the program.
- Private: Members are accessible only within the class and not from outside.
- Protected: Members are accessible within the class and derived classes.
Example:
public:
string name; // Accessible from outside
private:
int age; // Not accessible from outside
protected:
string address; // Accessible in derived classes
};
6. Member Functions and Data Members
- Member Functions:
- Functions defined within a class are known as member functions. They define the behavior of objects.
Example:
public:
double radius;
void setRadius(double r) {
radius = r;
}
double getArea() {
return 3.14 * radius * radius;
}
};
- Data Members:
- Variables defined within a class are called data members. They represent the state or attributes of an object.
Example:
public:
double balance; // Data member
void deposit(double amount) {
balance += amount;
}
};
7. Object-Oriented Concepts with Classes and Objects
- Encapsulation:
- The concept of hiding the internal workings of a class and only exposing necessary methods and data.
Example: Using getters and setters to control access to private data members.
private:
double balance;
public:
double getBalance() {
return balance;
}
void setBalance(double b) {
if (b >= 0) {
balance = b;
}
}
};
- Abstraction:
- Hiding complex implementation details and exposing only relevant information to the user.
- Example: Using a function like getBalance() to provide access to the balance without showing how the balance is stored or modified.
8. Best Practices with Classes and Objects
- Designing Efficient Classes:
- Keep classes focused on a single responsibility.
- Use proper naming conventions for class names, data members, and member functions.
- Make data members private and provide public getter/setter functions if necessary.
- Use Constructors for Initialization:
- Always initialize object data members using constructors to ensure objects are in a valid state.
- Avoid Direct Modification of Data Members:
- Use member functions to modify the internal state of an object, not direct access.
9. Exercises and Hands-On Practice
- Exercise 1:
- Create a Book class with title, author, and publication year as data members. Include functions to set and display book details.
- Exercise 2:
- Implement a BankAccount class with deposit and withdrawal functions. Ensure that withdrawal does not exceed the balance.
- Exercise 3:
- Write a program that demonstrates the use of constructors, destructors, and member functions for managing a Person
- Exercise 4:
- Implement a Student class with data members such as name, roll number, and grade. Write methods to input and display student details.
10. Conclusion and Summary
- Recap of key concepts: classes, objects, constructors, destructors, access modifiers, and encapsulation.
- Emphasize the importance of using classes to structure code and model real-world entities in a clear, organized manner.
Assessment and Quizzes
- Quiz 1: Multiple-choice questions on classes, objects, constructors, and destructors.
- Quiz 2: Code-based questions where students write a class and perform operations on its objects.
Constructors and Destructors
Module Overview:
In this module, we will explore constructors and destructors in C++. These special member functions play a critical role in initializing and cleaning up objects in object-oriented programming. A constructor initializes the object’s state when it is created, and a destructor is used to clean up resources when the object is destroyed. Understanding their usage and importance is essential for managing resources and maintaining efficient memory handling in C++ programs.
1. Introduction to Constructors
- What is a Constructor?
- A constructor is a special member function that is called automatically when an object of a class is created. Its primary role is to initialize the object’s data members with default or specified values.
- Constructors have the same name as the class and do not have a return type.
- They are used to allocate resources and set the initial state of an object.
2. Types of Constructors
There are three types of constructors in C++:
2.1 Default Constructor
- Definition:
- A constructor that takes no arguments and is used to initialize the object with default values.
- Usage:
- If no constructor is defined, the compiler provides a default constructor that initializes data members with default values (e.g., zero for integers, nullptr for pointers).
Example:
public:
string brand;
int year;
// Default Constructor
Car() {
brand = “Unknown”;
year = 0;
}
void displayInfo() {
cout << “Brand: ” << brand << “, Year: ” << year << endl;
}
};
int main() {
Car car1; // Calls the default constructor
car1.displayInfo(); // Output: Brand: Unknown, Year: 0
return 0;
}
2.2 Parameterized Constructor
- Definition:
- A constructor that takes parameters and initializes an object with specific values passed during object creation.
- Usage:
- Allows users to create objects with specific values at the time of object creation.
Example:
public:
string brand;
int year;
// Parameterized Constructor
Car(string b, int y) {
brand = b;
year = y;
}
void displayInfo() {
cout << “Brand: ” << brand << “, Year: ” << year << endl;
}
};
int main() {
Car car1(“Toyota”, 2020); // Calls the parameterized constructor
car1.displayInfo(); // Output: Brand: Toyota, Year: 2020
return 0;
}
2.3 Copy Constructor
- Definition:
- A constructor that creates a new object as a copy of an existing object.
- Usage:
- The copy constructor is called when an object is passed by value, returned by value, or when an object is copied directly.
Syntax:
Example:
public:
string brand;
int year;
// Parameterized Constructor
Car(string b, int y) {
brand = b;
year = y;
}
// Copy Constructor
Car(const Car& c) {
brand = c.brand;
year = c.year;
}
void displayInfo() {
cout << “Brand: ” << brand << “, Year: ” << year << endl;
}
};
int main() {
Car car1(“Honda”, 2021);
Car car2 = car1; // Calls the copy constructor
car2.displayInfo(); // Output: Brand: Honda, Year: 2021
return 0;
}
3. Destructor in C++
- What is a Destructor?
- A destructor is a special member function called automatically when an object goes out of scope or is deleted.
- Its main role is to release resources that the object may have acquired during its lifetime (e.g., dynamically allocated memory).
- A destructor has the same name as the class, but it is prefixed with a tilde (~) and does not take any arguments or return values.
- Usage of Destructor:
- Used to deallocate memory and perform any cleanup operations for an object before it is destroyed.
- Important when dealing with dynamic memory allocation and resource management.
Example:
public:
string brand;
int* year; // Pointer to dynamically allocated memory
// Constructor
Car(string b, int y) {
brand = b;
year = new int(y); // Dynamically allocated memory
}
// Destructor
~Car() {
delete year; // Deallocate the memory
cout << “Destructor called for ” << brand << endl;
}
void displayInfo() {
cout << “Brand: ” << brand << “, Year: ” << *year << endl;
}
};
int main() {
Car car1(“BMW”, 2022); // Constructor called
car1.displayInfo(); // Output: Brand: BMW, Year: 2022
return 0; // Destructor called automatically at the end of scope
}
4. Constructor and Destructor in Action
- Object Lifecycle:
- A constructor is called when an object is created, and a destructor is called when the object is destroyed (when it goes out of scope or is deleted).
- C++ handles constructor and destructor calls automatically in most cases. The programmer must ensure that destructors handle cleanup operations, especially for dynamic memory management.
- Order of Constructor and Destructor Calls:
- Constructors are called in the order of object creation (from left to right for an array of objects).
- Destructors are called in reverse order of the constructors, i.e., from right to left for an array of objects.
5. Important Points to Remember
- Constructor Overloading:
- You can overload constructors, meaning you can have multiple constructors with different parameter lists.
- Implicit Constructor and Destructor:
- If no constructor or destructor is defined explicitly, the compiler will automatically generate a default constructor and destructor for the class.
- Destructor in Derived Classes:
- If you have a derived class and the base class has a destructor, the derived class destructor should call the base class destructor to properly clean up resources.
6. Best Practices
- Always use constructors to initialize object data to ensure that your objects are in a valid state.
- Use destructors to release dynamically allocated memory to prevent memory leaks.
- If your class contains dynamically allocated memory (e.g., pointers), define a destructor to release that memory.
- If you define a constructor or destructor, remember to handle copy and assignment operations carefully.
7. Exercises and Hands-On Practice
- Exercise 1: Create a class Book that has a constructor to initialize the title and author, and a destructor that prints a message when the object is destroyed.
- Exercise 2: Write a program that uses a parameterized constructor to initialize an array of objects and prints their details.
- Exercise 3: Implement a class Person that dynamically allocates memory for a string (name) in the constructor and deletes the memory in the destructor.
8. Conclusion and Summary
- Constructors and destructors are crucial concepts in C++ to manage initialization and cleanup of objects.
- They help in resource management, especially when dealing with dynamic memory allocation and object lifecycle management.
- Understanding constructors and destructors leads to more efficient and error-free object-oriented programming practices.
Assessment and Quizzes
- Quiz 1: Multiple-choice questions on constructors, destructors, and their types.
- Quiz 2: Code-based questions where students create classes with constructors and destructors to manage dynamically allocated resources.
Inheritance in C++
Module Overview:
In this module, we will cover Inheritance, one of the core principles of Object-Oriented Programming (OOP) in C++. Inheritance allows a class to inherit properties and behaviors (i.e., methods and attributes) from another class. This feature promotes code reusability and establishes a relationship between classes. We will explore various types of inheritance, how to implement it, and understand its key concepts such as base and derived classes, method overriding, and access control.
1. Introduction to Inheritance
- What is Inheritance?
- Inheritance is a mechanism in C++ that allows one class (the derived class) to inherit the properties and methods of another class (the base class).
- The derived class can then reuse, modify, or extend the behavior of the base class, reducing code duplication and enhancing maintainability.
- Inheritance creates a hierarchy between base and derived classes, allowing objects of the derived class to behave like objects of the base class.
Basic Syntax:
// Base class members
};
class DerivedClass : public BaseClass {
// Derived class members
};
2. Types of Inheritance
C++ supports multiple types of inheritance. Here are the common types:
2.1 Single Inheritance
- Definition:
- In single inheritance, a derived class inherits from a single base class.
Example:
public:
void eat() {
cout << “Eating…” << endl;
}
};
class Dog : public Animal {
public:
void bark() {
cout << “Barking…” << endl;
}
};
int main() {
Dog dog;
dog.eat(); // Inherited function
dog.bark(); // Derived function
return 0;
}
- Explanation:
- The Dog class inherits the eat() function from the Animal class, enabling Dog objects to use this function.
2.2 Multiple Inheritance
- Definition:
- In multiple inheritance, a derived class can inherit from more than one base class.
Example:
public:
void eat() {
cout << “Eating…” << endl;
}
};
class Vehicle {
public:
void drive() {
cout << “Driving…” << endl;
}
};
class Car : public Animal, public Vehicle {
public:
void honk() {
cout << “Honking…” << endl;
}
};
int main() {
Car car;
car.eat(); // Inherited from Animal
car.drive(); // Inherited from Vehicle
car.honk(); // Derived function
return 0;
}
- Explanation:
- The Car class inherits from both Animal and Vehicle classes, enabling it to use functions from both base classes.
2.3 Multilevel Inheritance
- Definition:
- In multilevel inheritance, a class derives from another derived class, forming a chain of inheritance.
Example:
public:
void eat() {
cout << “Eating…” << endl;
}
};
class Mammal : public Animal {
public:
void giveBirth() {
cout << “Giving birth…” << endl;
}
};
class Dog : public Mammal {
public:
void bark() {
cout << “Barking…” << endl;
}
};
int main() {
Dog dog;
dog.eat(); // Inherited from Animal
dog.giveBirth(); // Inherited from Mammal
dog.bark(); // Derived function
return 0;
}
- Explanation:
- The Dog class is a derived class of Mammal, and Mammal itself is derived from Animal, creating a multilevel inheritance hierarchy.
2.4 Hierarchical Inheritance
- Definition:
- In hierarchical inheritance, multiple classes inherit from a single base class.
Example:
public:
void eat() {
cout << “Eating…” << endl;
}
};
class Dog : public Animal {
public:
void bark() {
cout << “Barking…” << endl;
}
};
class Cat : public Animal {
public:
void meow() {
cout << “Meowing…” << endl;
}
};
int main() {
Dog dog;
dog.eat(); // Inherited from Animal
dog.bark(); // Derived function
Cat cat;
cat.eat(); // Inherited from Animal
cat.meow(); // Derived function
return 0;
}
- Explanation:
- Both Dog and Cat inherit from the Animal class, forming a hierarchical structure.
2.5 Hybrid Inheritance
- Definition:
- Hybrid inheritance is a combination of two or more types of inheritance.
Example:
public:
void eat() {
cout << “Eating…” << endl;
}
};
class Vehicle {
public:
void drive() {
cout << “Driving…” << endl;
}
};
class FlyingVehicle {
public:
void fly() {
cout << “Flying…” << endl;
}
};
class FlyingCar : public Vehicle, public FlyingVehicle, public Animal {
public:
void honk() {
cout << “Honking…” << endl;
}
};
int main() {
FlyingCar fc;
fc.eat(); // Inherited from Animal
fc.drive(); // Inherited from Vehicle
fc.fly(); // Inherited from FlyingVehicle
fc.honk(); // Derived function
return 0;
}
- Explanation:
- The FlyingCar class inherits from multiple base classes (Vehicle, FlyingVehicle, and Animal), forming a hybrid inheritance structure.
3. Access Specifiers in Inheritance
- Public Inheritance:
- The most common form of inheritance. Members of the base class are inherited as public in the derived class.
- Example: class Derived : public Base { … };
- Protected Inheritance:
- Members of the base class are inherited as protected in the derived class.
- Example: class Derived : protected Base { … };
- Private Inheritance:
- Members of the base class are inherited as private in the derived class.
- Example: class Derived : private Base { … };
4. Method Overriding in Inheritance
- What is Method Overriding?
- Method overriding occurs when a derived class provides its own implementation of a method that is already defined in the base class.
- This is possible only if the base class method is virtual.
Example:
public:
virtual void sound() {
cout << “Some sound…” << endl;
}
};
class Dog : public Animal {
public:
void sound() override {
cout << “Barking…” << endl;
}
};
int main() {
Animal* animal = new Dog();
animal->sound(); // Output: Barking…
delete animal;
return 0;
}
5. Constructor and Destructor in Inheritance
- Constructor in Inheritance:
- When a derived class object is created, the constructor of the base class is called first, followed by the constructor of the derived class.
- Destructor in Inheritance:
- Similarly, when an object is destroyed, the destructor of the derived class is called first, followed by the destructor of the base class.
Example:
public:
Animal() {
cout << “Animal Constructor” << endl;
}
~Animal() {
cout << “Animal Destructor” << endl;
}
};
class Dog : public Animal {
public:
Dog() {
cout << “Dog Constructor” << endl;
}
~Dog() {
cout << “Dog Destructor” << endl;
}
};
int main() {
Dog dog; // Animal and Dog constructors are called
return 0; // Dog and Animal destructors are called
}
6. Best Practices in Inheritance
- Avoid deep inheritance chains: Inheritance hierarchies should be simple and easy to understand.
- Use composition over inheritance when necessary: Sometimes, it’s better to use composition (having an object as a member of another object) instead of inheritance, especially when there is no “is-a” relationship.
- Override methods carefully: Ensure that overridden methods have the same signature as the base class method.
- Use virtual destructors: To ensure proper cleanup in case of polymorphism.
7. Exercises and Hands-On Practice
- Exercise 1: Implement a class hierarchy representing different types of animals (e.g., Mammal, Bird, and Fish), and demonstrate method overriding.
- Exercise 2: Write a program using multiple inheritance to model a SmartPhone class that inherits from both Phone and Camera
- Exercise 3: Implement a class structure using multilevel inheritance to represent a hierarchy of employees (e.g., Person, Employee, Manager).
8. Conclusion and Summary
- Inheritance is a powerful feature in C++ that enables code reuse and creates hierarchical relationships between classes.
- By understanding how to implement and work with inheritance, you can design more flexible, maintainable, and scalable programs.
- Ensure proper use of constructors, destructors, and access specifiers to manage object behavior effectively.
Assessment and Quizzes
- Quiz 1: Multiple-choice questions to test understanding of inheritance types and concepts.
- Quiz 2: Code-based questions to practice method overriding and constructors in inheritance.
Polymorphism in C++
Module Overview:
In this module, we will cover Polymorphism, one of the fundamental concepts in Object-Oriented Programming (OOP). Polymorphism allows objects of different classes to be treated as objects of a common base class, with each class providing its own implementation of certain methods. The goal of this module is to help you understand the different types of polymorphism in C++, including compile-time and runtime polymorphism, and how to implement and use them effectively.
1. Introduction to Polymorphism
- What is Polymorphism?
- Polymorphism means “many forms”. It allows a single function, operator, or object to take many forms.
- It is a core principle of OOP, enabling methods to perform different actions based on the object that invokes them.
- In C++, polymorphism is classified into Compile-time Polymorphism and Runtime Polymorphism.
- Benefits of Polymorphism:
- Code Reusability: Write generic code that works across different classes.
- Flexibility: Make changes to the code without affecting other parts of the program.
- Maintainability: Update specific parts of the program without rewriting the entire system.
2. Types of Polymorphism
C++ supports two primary types of polymorphism:
2.1 Compile-Time Polymorphism
- Definition:
- Compile-time polymorphism occurs when the method to be invoked is determined at compile time. It is often achieved through Function Overloading and Operator Overloading.
- Function Overloading:
- Function overloading allows you to define multiple functions with the same name but different parameters. The correct function is chosen based on the argument types at compile time.
Example of Function Overloading:
public:
void print(int i) {
cout << “Integer: ” << i << endl;
}
void print(double d) {
cout << “Double: ” << d << endl;
}
void print(string s) {
cout << “String: ” << s << endl;
}
};
int main() {
Printer printer;
printer.print(5); // Calls print(int)
printer.print(3.14); // Calls print(double)
printer.print(“Hello”); // Calls print(string)
return 0;
}
- Operator Overloading:
- Operator overloading allows you to redefine the behavior of operators (e.g., +, -, *, []) for user-defined types (classes).
Example of Operator Overloading:
private:
int real, imag;
public:
Complex(int r = 0, int i = 0) : real(r), imag(i) {}
Complex operator + (const Complex& obj) {
return Complex(real + obj.real, imag + obj.imag);
}
void display() {
cout << real << ” + ” << imag << “i” << endl;
}
};
int main() {
Complex c1(2, 3), c2(4, 5);
Complex c3 = c1 + c2; // Calls the overloaded + operator
c3.display(); // Output: 6 + 8i
return 0;
}
- Key Points of Compile-Time Polymorphism:
- The method is selected at compile time.
- Achieved using function overloading and operator overloading.
- Works based on function signatures or operator definitions.
2.2 Runtime Polymorphism
- Definition:
- Runtime polymorphism occurs when the method to be invoked is determined at runtime. It is implemented using function overriding and is typically associated with inheritance and virtual functions.
- The main feature of runtime polymorphism is method overriding, where a derived class provides a specific implementation of a function already defined in its base class.
- Virtual Functions:
- A function in the base class is declared as virtual to allow it to be overridden in derived classes.
- If a function is called using a base class pointer or reference, the appropriate overridden function in the derived class is invoked at runtime.
Example of Runtime Polymorphism:
public:
virtual void sound() {
cout << “Animal makes sound” << endl;
}
};
class Dog : public Animal {
public:
void sound() override {
cout << “Dog barks” << endl;
}
};
class Cat : public Animal {
public:
void sound() override {
cout << “Cat meows” << endl;
}
};
int main() {
Animal* animal1 = new Dog();
Animal* animal2 = new Cat();
animal1->sound(); // Output: Dog barks
animal2->sound(); // Output: Cat meows
delete animal1;
delete animal2;
return 0;
}
- Key Points of Runtime Polymorphism:
- Achieved using virtual functions and function overriding.
- The method is selected at runtime, based on the object type (not the pointer/reference type).
- Dynamic binding occurs, meaning the method to be called is determined dynamically at runtime.
- Requires the use of base class pointers or references.
3. Function Overriding
- What is Function Overriding?
- When a derived class provides its own implementation of a function that is already defined in the base class, it is called function overriding.
- The function in the derived class must have the same signature (name, return type, and parameters) as the one in the base class.
- In C++, the base class function must be declared as virtual to allow overriding.
Example of Function Overriding:
public:
virtual void draw() {
cout << “Drawing Shape” << endl;
}
};
class Circle : public Shape {
public:
void draw() override {
cout << “Drawing Circle” << endl;
}
};
class Square : public Shape {
public:
void draw() override {
cout << “Drawing Square” << endl;
}
};
int main() {
Shape* shape1 = new Circle();
Shape* shape2 = new Square();
shape1->draw(); // Output: Drawing Circle
shape2->draw(); // Output: Drawing Square
delete shape1;
delete shape2;
return 0;
}
4. Virtual Destructors
- Why Use Virtual Destructors?
- When using polymorphism with base class pointers to derived class objects, it’s important to have a virtual destructor to ensure proper cleanup of dynamically allocated resources.
- Without a virtual destructor, the destructor of the base class is called when a derived class object is deleted through a base class pointer, leading to memory leaks or undefined behavior.
Example of Virtual Destructor:
public:
virtual ~Base() {
cout << “Base Destructor” << endl;
}
};
class Derived : public Base {
public:
~Derived() override {
cout << “Derived Destructor” << endl;
}
};
int main() {
Base* ptr = new Derived();
delete ptr; // Ensures both base and derived destructors are called
return 0;
}
5. Pure Virtual Functions and Abstract Classes
- Pure Virtual Function:
- A pure virtual function is a function declared in the base class with no implementation and is marked with = 0.
- A class that contains at least one pure virtual function is called an abstract class and cannot be instantiated directly.
Example of Abstract Class:
public:
virtual void draw() = 0; // Pure virtual function
virtual ~Shape() {}
};
class Circle : public Shape {
public:
void draw() override {
cout << “Drawing Circle” << endl;
}
};
class Square : public Shape {
public:
void draw() override {
cout << “Drawing Square” << endl;
}
};
int main() {
// Shape shape; // Error: Cannot instantiate an abstract class
Shape* shape1 = new Circle();
shape1->draw(); // Output: Drawing Circle
Shape* shape2 = new Square();
shape2->draw(); // Output: Drawing Square
delete shape1;
delete shape2;
return 0;
}
6. Best Practices for Polymorphism
- Use Virtual Functions for runtime polymorphism, especially when designing class hierarchies.
- Avoid Virtual Functions in Performance-Critical Code: Virtual function calls incur a runtime overhead due to dynamic dispatch.
- Use Abstract Classes and Interfaces to define common functionality in a class hierarchy, allowing derived classes to provide their own specific implementations.
7. Exercises and Hands-On Practice
- Exercise 1: Create a base class Vehicle with virtual functions for start() and stop(). Derive classes Car and Truck that override these functions. Demonstrate polymorphism by calling these functions using base class pointers.
- Exercise 2: Implement a simple shape hierarchy with a base class Shape and derived classes Rectangle and Circle. Demonstrate polymorphism and function overriding for the area()
- Exercise 3: Write a program that demonstrates the use of pure virtual functions by creating an abstract class Shape and derived classes like Circle and Rectangle.
8. Conclusion and Summary
- Polymorphism is a powerful feature of C++ that allows for more flexible and reusable code.
- Compile-time polymorphism is achieved through function and operator overloading, whereas runtime polymorphism is achieved through virtual functions and function overriding.
- By understanding and using polymorphism effectively, you can design more efficient, maintainable, and scalable programs.
Assessment and Quizzes
- Quiz 1: Multiple-choice questions to test your understanding of polymorphism types.
- Quiz 2: Code-based questions to practice function overloading, overriding, and virtual functions.
Operator Overloading in C++
Module Overview:
In this module, we will delve into Operator Overloading, a key feature in C++ that allows you to redefine the functionality of operators for user-defined types (classes). This enables operators like +, -, *, and == to be used with objects in the same way they are used with primitive types, making your code more intuitive and expressive.
1. Introduction to Operator Overloading
- What is Operator Overloading?
- Operator Overloading is a feature that allows you to define how operators behave when applied to objects of a user-defined class.
- By overloading an operator, you can customize its functionality to fit your class, enabling you to use operators for objects in a way that mirrors their use with basic data types.
- Why Use Operator Overloading?
- Operator overloading helps make the code more readable and intuitive.
- It enhances the expressiveness of the language by enabling object manipulation using familiar operators.
- Important Points:
- Operator overloading does not change the precedence or associativity of operators.
- Not all operators can be overloaded. Some operators, such as ::, .*, and sizeof, cannot be overloaded.
- Operator overloading can be done using either member functions or non-member functions (friend functions).
2. Syntax of Operator Overloading
To overload an operator, you need to define a function with a special name (the operator keyword followed by the operator symbol). The basic syntax is:
// implementation of operator
}
Example:
cpp
class Complex {
private:
int real, imag;
public:
Complex(int r, int i) : real(r), imag(i) {}
// Overloading the + operator to add two Complex objects
Complex operator + (const Complex& obj) {
return Complex(real + obj.real, imag + obj.imag);
}
void display() {
cout << real << ” + ” << imag << “i” << endl;
}
};
3. Types of Operator Overloading
There are several types of operators that can be overloaded in C++:
3.1 Unary Operator Overloading
- Definition: Unary operators work on a single operand. Examples include ++, –, !, + (unary plus), and – (unary minus).
Example:
private:
int real, imag;
public:
Complex(int r = 0, int i = 0) : real(r), imag(i) {}
// Overloading the unary – operator
Complex operator – () {
return Complex(-real, -imag);
}
void display() {
cout << real << ” + ” << imag << “i” << endl;
}
};
int main() {
Complex c1(3, 4);
Complex c2 = -c1; // Calls the overloaded unary – operator
c2.display(); // Output: -3 + -4i
return 0;
}
3.2 Binary Operator Overloading
- Definition: Binary operators operate on two operands. Examples include +, -, *, /, ==, and =.
Example:
private:
int real, imag;
public:
Complex(int r = 0, int i = 0) : real(r), imag(i) {}
// Overloading the + operator (binary operator)
Complex operator + (const Complex& obj) {
return Complex(real + obj.real, imag + obj.imag);
}
void display() {
cout << real << ” + ” << imag << “i” << endl;
}
};
int main() {
Complex c1(2, 3), c2(4, 5);
Complex c3 = c1 + c2; // Calls the overloaded + operator
c3.display(); // Output: 6 + 8i
return 0;
}
3.3 Assignment Operator Overloading
- Definition: The assignment operator = is overloaded to allow assigning one object to another. This is necessary to prevent shallow copying when dealing with dynamically allocated memory.
Example:
private:
int* real;
int* imag;
public:
Complex(int r = 0, int i = 0) {
real = new int(r);
imag = new int(i);
}
// Overloading the assignment operator
Complex& operator = (const Complex& obj) {
if (this == &obj) // Check for self-assignment
return *this;
*real = *obj.real;
*imag = *obj.imag;
return *this;
}
void display() {
cout << *real << ” + ” << *imag << “i” << endl;
}
~Complex() {
delete real;
delete imag;
}
};
int main() {
Complex c1(3, 4);
Complex c2 = c1; // Calls the overloaded assignment operator
c2.display(); // Output: 3 + 4i
return 0;
}
3.4 Comparison Operator Overloading
- Definition: Overload operators like ==, !=, <, >, <=, and >= to compare objects based on custom-defined logic.
Example:
private:
int real, imag;
public:
Complex(int r = 0, int i = 0) : real(r), imag(i) {}
// Overloading the == operator
bool operator == (const Complex& obj) {
return (real == obj.real && imag == obj.imag);
}
void display() {
cout << real << ” + ” << imag << “i” << endl;
}
};
int main() {
Complex c1(3, 4), c2(3, 4), c3(5, 6);
cout << (c1 == c2) << endl; // Output: 1 (True)
cout << (c1 == c3) << endl; // Output: 0 (False)
return 0;
}
4. Rules for Operator Overloading
- Operators that cannot be overloaded:
- :: (Scope resolution operator)
- . (Member access operator)
- .* (Pointer-to-member operator)
- sizeof
- typeid
- , (Comma operator)
- Rules:
- The number of operands for overloaded operators must be the same as the operator in its standard form.
- You cannot change the precedence or associativity of operators.
- You cannot overload operators that are used to define the basic flow of control (like if, while, etc.).
- Operator overloading must make sense in the context of the class.
5. Friend Functions for Operator Overloading
- Definition: In some cases, you may need to overload operators using a friend function. This allows non-member functions to access private and protected members of the class.
- When to use: Friend functions are often used for operators that need access to private members but cannot be implemented as member functions (e.g., <<, >> for stream insertion/extraction).
Example:
private:
int real, imag;
public:
Complex(int r = 0, int i = 0) : real(r), imag(i) {}
// Friend function to overload the << operator
friend ostream& operator << (ostream& out, const Complex& c);
void display() {
cout << real << ” + ” << imag << “i” << endl;
}
};
// Definition of the friend function
ostream& operator << (ostream& out, const Complex& c) {
out << c.real << ” + ” << c.imag << “i”;
return out;
}
int main() {
Complex c(3, 4);
cout << c << endl; // Output: 3 + 4i
return 0;
}
6. Best Practices for Operator Overloading
- Maintain the natural meaning of operators: Overloading should make logical sense. For example, overloading the + operator for a complex number class to perform addition of complex numbers is intuitive and meaningful.
- Avoid overloading operators that may cause confusion: Some operators, such as the ++ and –, should only be overloaded in specific contexts.
- Use member functions when the left-hand operand is an object of the class. Use non-member functions (friend functions) when the left-hand operand is not an object of the class.
- Use the assignment operator carefully to prevent shallow copying and avoid resource leakage, particularly with dynamic memory management.
7. Exercises and Hands-On Practice
- Exercise 1: Overload the + operator to add two Time objects, where each Time object holds hours and minutes.
- Exercise 2: Overload the << and >> operators to input and output data from a Book
- Exercise 3: Overload the [] operator to access elements in a Matrix
8. Conclusion and Summary
- Operator overloading enhances the flexibility and expressiveness of your C++ programs.
- It allows you to use standard operators with user-defined classes to make code more intuitive.
- Unary operators, binary operators, and comparison operators are some of the most commonly overloaded operators.
- Using friend functions for certain operator overloads can be an effective way to provide non-member access to private class members.
Assessment and Quizzes
- Quiz 1: Multiple-choice questions to test your understanding of operator overloading concepts.
- Quiz 2: Code-based exercises where you implement operator overloading for different operators.
Friend Functions and Friend Classes in C++
Module Overview:
In this module, we will explore Friend Functions and Friend Classes in C++. These concepts are crucial for cases where non-member functions or classes need access to the private and protected members of a class. Friend functions and friend classes allow for greater flexibility in design by breaking encapsulation in a controlled way, while still maintaining the integrity of the class’s internal structure.
1. Introduction to Friend Functions
- What is a Friend Function?
- A friend function is a function that is declared within a class but is not a member of that class.
- A friend function can access all private and protected members of the class, even though it is not a member function.
- Friend functions are declared using the friend
- Why Use Friend Functions?
- Non-member function access: Friend functions are useful when you need a non-member function to access private data of a class.
- Operator Overloading: Friend functions are often used for operator overloading (e.g., <<, >> stream operators).
- Efficient code design: Friend functions allow certain external functions to interact with a class without violating encapsulation completely.
Syntax of a Friend Function: A friend function is declared within the class, but it is defined outside the class.
private:
int data;
public:
// Friend function declaration
friend void display(ClassName& obj);
};
// Friend function definition outside the class
void display(ClassName& obj) {
cout << obj.data << endl; // Accessing private member of ClassName
}
Example of a Friend Function:
private:
double length;
public:
Box(double l = 0) : length(l) {}
// Friend function declaration
friend void printLength(Box& b);
};
// Friend function definition
void printLength(Box& b) {
cout << “Length of the box: ” << b.length << endl;
}
int main() {
Box b(5);
printLength(b); // Friend function can access private members
return 0;
}
Output:
mathematica
Length of the box: 5
2. Introduction to Friend Classes
- What is a Friend Class?
- A friend class is a class that is allowed to access the private and protected members of another class.
- Friend classes are declared by using the friend keyword inside the class whose members need to be accessed.
- Why Use Friend Classes?
- Multiple class interactions: When two or more classes need to work closely together and share their private data, using friend classes makes it easier.
- Tight coupling: In cases where certain classes are tightly coupled and need intimate access to each other’s internals, friend classes can be a useful feature.
Syntax of a Friend Class: A friend class is declared inside the class whose private data it needs to access.
private:
int data;
public:
ClassA() : data(10) {}
// Friend class declaration
friend class ClassB;
};
class ClassB {
public:
void display(ClassA& obj) {
cout << “Data from ClassA: ” << obj.data << endl;
}
};
Example of a Friend Class:
private:
string model;
int speed;
public:
Car(string m, int s) : model(m), speed(s) {}
// Declaring the class ‘Race’ as a friend
friend class Race;
};
class Race {
public:
void displayInfo(Car& car) {
cout << “Car model: ” << car.model << endl;
cout << “Car speed: ” << car.speed << ” km/h” << endl;
}
};
int main() {
Car car1(“Ferrari”, 220);
Race race;
race.displayInfo(car1); // Race class can access private members of Car class
return 0;
}
Output:
Car speed: 220 km/h
3. Friend Functions vs Member Functions
- Friend Functions:
- A friend function is not a member of the class.
- It has access to the private and protected members of the class.
- Friend functions can be used to overload operators or implement helper functions that need access to private data.
- Member Functions:
- A member function is defined within the class and can access all private and protected members of that class.
- Member functions have an implicit this pointer, which refers to the current object.
- When to Use Each:
- Use friend functions when a function that needs access to a class’s private members cannot logically be part of the class itself (e.g., for operator overloading).
- Use member functions when the function is inherently part of the class and logically works with the class’s data.
4. Advantages and Disadvantages of Friend Functions and Friend Classes
- Advantages of Friend Functions:
- Allows access to private and protected data of a class from external functions.
- Helps in operator overloading and non-member utility functions.
- Disadvantages of Friend Functions:
- Breaks encapsulation to some extent by allowing external functions to access the class’s private members.
- Overuse can lead to tightly coupled code, making it harder to maintain.
- Advantages of Friend Classes:
- Allows tight coupling between classes that need to work closely together.
- Provides a way for classes to share private members with each other without exposing them to the outside world.
- Disadvantages of Friend Classes:
- Can lead to less modular code since the classes are tightly coupled.
- Overuse can compromise encapsulation and object-oriented principles like separation of concerns.
5. Use Cases of Friend Functions and Friend Classes
- Operator Overloading: Overloading stream operators (<<, >>) for input and output typically requires using friend functions, as these operators are often implemented outside the class.
- Access to Private Data in Non-Member Functions: Functions that need to perform complex operations on a class but aren’t naturally a part of the class (like mathematical computations or utility functions) might be better as friend functions.
- Tightly Coupled Classes: In situations where two classes need to collaborate closely (like Car and Race in the previous example), making one class a friend of the other allows for intimate access to the internals of each class.
6. Best Practices
- Limit the use of friend functions: Use them sparingly, as they break encapsulation. Overusing them can lead to code that is difficult to maintain.
- Prefer member functions: Whenever possible, use member functions to operate on the class’s data. Only use friend functions when absolutely necessary.
- Limit friend class use: Friend classes should be used when there’s a clear reason for two classes to share intimate access to each other’s data, such as in tightly coupled designs.
7. Exercises and Hands-On Practice
- Exercise 1: Implement a Friend Function that swaps the values of two private variables in a class.
- Exercise 2: Create two classes, BankAccount and Transaction, and make Transaction a friend class of BankAccount so it can access the private balance.
- Exercise 3: Implement Friend Functions to overload + and == for a Complex class that represents complex numbers.
8. Conclusion and Summary
- Friend Functions and Friend Classes allow you to extend the accessibility of class members without violating the integrity of object-oriented design principles too much.
- Friend Functions allow external functions to access private members of a class, useful for operator overloading and non-member utility functions.
- Friend Classes allow a class to share its private members with another class, which can be helpful in tightly coupled systems.
- While powerful, both friend functions and classes should be used carefully to maintain good encapsulation and modularity.
Assessment and Quizzes
- Quiz 1: Multiple-choice questions on the use cases and benefits of friend functions and classes.
- Quiz 2: Code-based exercise where you create a friend function and a friend class in a real-world example.
