Abstract Classes and Interfaces in C++
Module Overview:
In this module, we will delve into Abstract Classes and Interfaces, two fundamental concepts of object-oriented programming (OOP). These concepts are key for designing flexible and scalable systems that focus on abstraction. Understanding abstract classes and interfaces allows you to define common interfaces for different types of objects, ensuring a clean and maintainable design, especially when working with polymorphism and inheritance.
1. Abstract Classes in C++
- What is an Abstract Class?
- An abstract class is a class that cannot be instantiated, meaning you cannot create objects directly from it.
- Abstract classes are designed to be base classes for other classes that derive from them.
- An abstract class contains at least one pure virtual function, which forces derived classes to implement that function.
- Why Use Abstract Classes?
- Provide a common interface: They define a common interface for derived classes but leave the implementation details to the derived classes.
- Enable polymorphism: Abstract classes are often used in scenarios where you want to provide a base interface but leave the specific behavior of that interface to be defined by subclasses.
- Promote code reusability: Abstract classes help centralize common functionalities while allowing subclasses to specialize.
- Pure Virtual Function:
- A pure virtual function is a function declared within an abstract class that has no implementation in the base class.
- It is specified by appending = 0 to the function declaration.
Example:
public:
virtual void draw() = 0; // Pure virtual function
virtual double area() = 0; // Another pure virtual function
};
Syntax of Abstract Class:
public:
virtual void show() = 0; // Pure virtual function
};
Example of an Abstract Class:
public:
virtual void sound() = 0; // Pure virtual function
};
class Dog : public Animal {
public:
void sound() {
cout << “Bark” << endl;
}
};
class Cat : public Animal {
public:
void sound() {
cout << “Meow” << endl;
}
};
int main() {
// Animal a; // Error: Cannot instantiate an abstract class
Dog dog;
dog.sound(); // Output: Bark
Cat cat;
cat.sound(); // Output: Meow
return 0;
}
Output:
Bark
Meow
- Key Points:
- Abstract classes provide a way to define an interface that can be inherited by derived classes.
- They allow you to enforce that derived classes implement certain functions.
- A class containing at least one pure virtual function is considered abstract and cannot be instantiated.
2. Interfaces in C++
- What is an Interface?
- In C++, an interface is typically a class that contains only pure virtual functions.
- Interfaces provide a way to specify a contract that other classes must adhere to, without dictating how the functions should be implemented.
- Why Use Interfaces?
- Decouple implementation from interface: An interface allows the design of systems where the implementation can change independently of the code that uses the interface.
- Multiple inheritance: C++ allows a class to inherit multiple interfaces, which can help build flexible systems by providing multiple functionality contracts without the need for complex inheritance hierarchies.
- Difference Between Abstract Class and Interface:
- An abstract class can have both pure virtual functions (like an interface) and regular member functions with implementation.
- An interface (in C++ terminology) is usually a class with only pure virtual functions and no data members or implemented functions.
- In C++, interfaces are generally implemented using abstract classes that only have pure virtual functions.
Syntax of Interface: An interface is a class with only pure virtual functions:
public:
virtual void doSomething() = 0;
virtual void performAction() = 0;
};
Example of an Interface:
public:
virtual void print() = 0; // Pure virtual function (interface method)
};
class Document : public Printable {
public:
void print() {
cout << “Printing Document” << endl;
}
};
class Image : public Printable {
public:
void print() {
cout << “Printing Image” << endl;
}
};
int main() {
Document doc;
doc.print(); // Output: Printing Document
Image img;
img.print(); // Output: Printing Image
return 0;
}
Output:mathematica
Printing Document
Printing Image
- Key Points:
- In C++, interfaces are generally abstract classes with only pure virtual functions.
- Interfaces define a contract that must be fulfilled by any implementing class.
- They allow for multiple inheritance, enabling a class to implement multiple interfaces.
3. Implementing Multiple Interfaces
- What is Multiple Interface Inheritance?
- In C++, a class can implement more than one interface. This is a powerful feature because it allows a class to provide functionality from multiple sources.
- Why Use Multiple Interface Inheritance?
- Flexibility: Multiple interface inheritance allows a class to inherit functionality from different sources, making the design more modular and flexible.
- Separation of concerns: By splitting functionality into different interfaces, you can ensure that each class is responsible for only a part of the system’s functionality.
Syntax for Multiple Interface Inheritance:
public:
virtual void function1() = 0;
};
class Interface2 {
public:
virtual void function2() = 0;
};
class Derived : public Interface1, public Interface2 {
public:
void function1() {
cout << “Function1 implementation” << endl;
}
void function2() {
cout << “Function2 implementation” << endl;
}
};
Example of Multiple Interface Implementation:
public:
virtual void draw() = 0;
};
class Movable {
public:
virtual void move() = 0;
};
class Rectangle : public Drawable, public Movable {
public:
void draw() {
cout << “Drawing Rectangle” << endl;
}
void move() {
cout << “Moving Rectangle” << endl;
}
};
int main() {
Rectangle rect;
rect.draw(); // Output: Drawing Rectangle
rect.move(); // Output: Moving Rectangle
return 0;
}
Output:mathematica
Drawing Rectangle
Moving Rectangle
4. Key Differences Between Abstract Classes and Interfaces
| Feature | Abstract Class | Interface |
| Member Functions | Can have both pure virtual and regular functions. | Can only have pure virtual functions. |
| Data Members | Can have data members. | Cannot have data members. |
| Inheritance | Can be used for single or multiple inheritance. | Used for multiple inheritance. |
| Purpose | Used to provide a common base with shared functionality and forced implementation. | Used to define a contract that classes must follow. |
| Constructor/Destructor | Can have constructors and destructors. | Cannot have constructors or destructors. |
5. Best Practices
- Use Abstract Classes when you need to provide some base functionality, but you also want to enforce that derived classes implement certain methods.
- Use Interfaces when you need to define a set of functions that can be implemented by any class, regardless of its inheritance hierarchy.
- Limit the use of Multiple Inheritance: Although C++ supports multiple inheritance, it can introduce complexity. Be cautious and use it only when it makes sense.
- Favor Composition Over Inheritance: Prefer composition (having objects as members) when multiple interfaces are needed, as it tends to reduce complexity and coupling.
6. Exercises and Hands-On Practice
- Exercise 1: Create an abstract class Shape with a pure virtual function area() and derive classes Rectangle and Circle from it. Implement area() in the derived classes.
- Exercise 2: Design a Vehicle interface with methods start() and stop(). Implement it in classes Car and Bicycle.
- Exercise 3: Implement a system where a class implements multiple interfaces. Create interfaces Readable and Writable, and implement them in a File
7. Conclusion and Summary
- Abstract Classes: Provide a base class with partial implementation and enforce that derived classes implement specific functions through pure virtual methods.
- Interfaces: Define a contract with only pure virtual functions that must be implemented by any class that claims to implement the interface.
- Multiple Interface Inheritance: C++ allows a class to implement multiple interfaces, promoting modularity and flexibility.
- Best Practices: Abstract classes and interfaces provide a solid foundation for object-oriented design, but should be used carefully to avoid complexity and ensure maintainability.
Assessment and Quizzes
- Quiz 1: Multiple-choice questions about the differences between abstract classes and interfaces.
- Quiz 2: Hands-on coding exercise where students implement an abstract class and interfaces in a real-world scenario.
Virtual Functions in C++
Module Overview:
In this module, we will explore Virtual Functions, one of the core features of polymorphism in object-oriented programming (OOP). Virtual functions allow you to define functions in a base class that can be overridden by derived classes. This dynamic function binding enables the program to choose the appropriate function at runtime, which is fundamental to achieving runtime polymorphism.
1. What is a Virtual Function?
- Definition: A virtual function is a function in the base class that can be overridden in derived classes. Virtual functions are used to achieve runtime polymorphism by allowing derived classes to provide specific implementations of the function.
- Why Virtual Functions?
- They allow derived classes to override a base class function and provide a different implementation.
- They help achieve dynamic polymorphism, where the function to be executed is determined at runtime based on the type of the object, not the type of the pointer/reference.
- They are essential when working with inheritance hierarchies, allowing for more flexible and extensible designs.
Syntax of Virtual Function: To declare a virtual function in the base class, you use the virtual keyword:
public:
virtual void show() {
cout << “Base class show function.” << endl;
}
};
2. Virtual Function Mechanism
- How Virtual Functions Work: Virtual functions use a mechanism called virtual table (vtable). When a class has a virtual function, a virtual table is created. Each class that contains virtual functions has its own vtable.
- When a function is called via a base class pointer or reference, the appropriate function is determined at runtime using the vtable.
- This is also known as dynamic dispatch or late binding, as opposed to early binding (compile-time).
- Virtual Table (vtable):
- The vtable is essentially a lookup table for function pointers. Each class with virtual functions has a vtable, which stores the addresses of the overridden functions for that class.
- When a virtual function is called on an object, the vtable for that object’s class is used to determine which function to call.
3. Overriding Virtual Functions in Derived Classes
- Overriding Virtual Functions: When a derived class defines a function with the same signature as a virtual function in the base class, the function in the derived class overrides the base class function.
- The override keyword (optional in C++) is used to explicitly indicate that a function is overriding a base class virtual function.
public:
virtual void display() {
cout << “Display from Base class” << endl;
}
};
class Derived : public Base {
public:
void display() override { // Overriding the base class function
cout << “Display from Derived class” << endl;
}
};
int main() {
Base* basePtr;
Derived derivedObj;
basePtr = &derivedObj;
basePtr->display(); // Output: Display from Derived class
return 0;
}
Output:
csharp
Display from Derived class
- Explanation: The function display() is overridden in the derived class. When the base class pointer (basePtr) is used to call the function, the derived class’s implementation of display() is called, demonstrating runtime polymorphism.
4. Virtual Destructors
- Importance of Virtual Destructors: Virtual destructors are essential when you have a base class pointer pointing to a derived class object. If the destructor is not virtual, the destructor of the derived class will not be called, leading to potential resource leaks.
- Always declare destructors as virtual in base classes if you are using inheritance and dynamic memory allocation.
Syntax of Virtual Destructor:
public:
virtual ~Base() {
cout << “Base class destructor” << endl;
}
};
Example of Virtual Destructor:
public:
virtual ~Base() {
cout << “Base class destructor called” << endl;
}
};
class Derived : public Base {
public:
~Derived() {
cout << “Derived class destructor called” << endl;
}
};
int main() {
Base* ptr = new Derived();
delete ptr; // Proper cleanup due to virtual destructor
return 0;
}
Output:
kotlin
Derived class destructor called
Base class destructor called
- Explanation: The virtual destructor ensures that both the base class and derived class destructors are called correctly when deleting an object through a base class pointer.
5. Pure Virtual Functions
- What is a Pure Virtual Function? A pure virtual function is a function that has no implementation in the base class and must be implemented in any derived class. It is declared by assigning = 0 at the end of the function declaration.
- A class with at least one pure virtual function is an abstract class, and objects cannot be instantiated from it.
public:
virtual void draw() = 0; // Pure virtual function
};
Example of Pure Virtual Function:
public:
virtual void draw() = 0; // Pure virtual function
};
class Circle : public Shape {
public:
void draw() override {
cout << “Drawing Circle” << endl;
}
};
int main() {
// Shape shapeObj; // Error: Cannot instantiate abstract class
Circle circleObj;
circleObj.draw(); // Output: Drawing Circle
return 0;
}
Output:
mathematica
Drawing Circle
6. Virtual Functions and Polymorphism
- Polymorphism and Virtual Functions: Virtual functions enable runtime polymorphism. When a function is called on an object through a base class pointer, the appropriate function for the object’s actual type is executed, not the base class function.
- This mechanism allows for flexibility and extensibility in object-oriented designs.
public:
virtual void sound() {
cout << “Animal sound” << endl;
}
};
class Dog : public Animal {
public:
void sound() override {
cout << “Bark” << endl;
}
};
class Cat : public Animal {
public:
void sound() override {
cout << “Meow” << endl;
}
};
int main() {
Animal* animalPtr;
Dog dog;
Cat cat;
animalPtr = &dog;
animalPtr->sound(); // Output: Bark
animalPtr = &cat;
animalPtr->sound(); // Output: Meow
return 0;
}
Output:
Bark
Meow
Explanation:
Even though animalPtr is a pointer of type Animal*, the appropriate function is called based on the actual object type (Dog or Cat). This is an example of runtime polymorphism, facilitated by virtual functions.
7. Key Points to Remember
- Virtual functions allow derived classes to override functions from the base class.
- The virtual keyword is used to declare a function as virtual.
- Virtual functions enable runtime polymorphism, where the function called is determined at runtime, not at compile-time.
- Virtual destructors are important for proper cleanup in class hierarchies.
- Pure virtual functions make a class abstract and enforce that derived classes implement them.
8. Best Practices
- Use Virtual Functions when you need polymorphic behavior.
- Declare Destructors as Virtual in base classes that will be used polymorphically.
- Use Pure Virtual Functions for defining abstract interfaces that must be implemented by derived classes.
- Avoid Using Virtual Functions in classes that are not meant to be inherited from (i.e., in leaf classes where no further derivation is expected).
9. Exercises and Hands-On Practice
- Exercise 1: Create a base class Vehicle with a virtual function move(). Derive classes Car and Bike and override move() in each derived class.
- Exercise 2: Implement a scenario where a base class Shape has a virtual function area(). Derive classes Circle and Rectangle, and implement area() in each derived class.
- Exercise 3: Create a class Employee with a virtual destructor, and implement a derived class Manager. Use a base class pointer to delete a dynamically allocated object of type Manager and observe the output.
10. Conclusion and Summary
- Virtual functions allow you to implement runtime polymorphism, where the correct function is called based on the object’s actual type, not the pointer type.
- They are essential for building flexible and extensible systems, especially in object-oriented designs involving inheritance.
- Virtual destructors ensure proper cleanup of resources when objects are deleted through base class pointers.
Assessment and Quizzes
- Quiz 1: Multiple-choice questions about virtual functions and their role in polymorphism.
- Quiz 2: Hands-on coding challenge where students create a class hierarchy using virtual functions.
Function Overloading and Overriding in C++
Module Overview:
In this module, we will cover Function Overloading and Function Overriding, two important concepts in C++ that allow developers to create more flexible and readable code. While function overloading allows multiple functions with the same name but different parameters, function overriding lets derived classes redefine base class functions for runtime polymorphism. These features are foundational to object-oriented programming in C++.
1. Function Overloading
- Definition: Function Overloading occurs when multiple functions with the same name are defined in the same scope but differ in the number or types of their parameters. C++ uses the function signature (function name and parameter list) to distinguish between overloaded functions.
- Why Use Function Overloading?
- Improves Code Readability: Allows you to use the same function name for different functionalities that are conceptually similar.
- Simplifies Code: Reduces the need for creating multiple function names for similar tasks.
Basic Syntax of Function Overloading:
public:
void display(int x) {
cout << “Integer: ” << x << endl;
}
void display(double x) {
cout << “Double: ” << x << endl;
}
void display(string x) {
cout << “String: ” << x << endl;
}
};
Example:
using namespace std;
class Printer {
public:
void print(int i) {
cout << “Printing integer: ” << i << endl;
}
void print(double d) {
cout << “Printing double: ” << d << endl;
}
void print(string s) {
cout << “Printing string: ” << s << endl;
}
};
int main() {
Printer p;
p.print(10); // Calls print(int)
p.print(3.14); // Calls print(double)
p.print(“Hello”); // Calls print(string)
return 0;
}
Output:
php
Printing integer: 10
Printing double: 3.14
Printing string: Hello
- Explanation: Here, the print() function is overloaded with different parameter types (int, double, string). Based on the argument type passed, the appropriate function is called.
2. Rules of Function Overloading
- Same Name: The overloaded functions must have the same name.
- Different Parameter Lists: The functions must differ in either the number of parameters or the types of parameters.
- Return Type Does Not Matter: Function overloading is determined by parameter lists, not by return type.
Example:
void func(double a); // Overloaded function 2
void func(int a, double b); // Overloaded function 3
Note: Function overloading cannot occur if the functions only differ by their return type.
int func(int x); // Function 1
double func(int x); // Function 2 (invalid overload)
3. Function Overriding
- Definition: Function Overriding occurs when a derived class redefines a base class function. The overridden function in the derived class must have the same name, return type, and parameter list as the function in the base class. The key difference between overloading and overriding is that overloading occurs at compile-time, whereas overriding happens at runtime.
- Why Use Function Overriding?
- Runtime Polymorphism: It allows a program to decide at runtime which function to invoke based on the object type.
- Extend Functionality: It enables derived classes to provide specific implementations of a function defined in a base class.
Basic Syntax of Function Overriding: To override a function, use the same function signature in the derived class.
public:
virtual void display() { // Virtual function in base class
cout << “Base class display function” << endl;
}
};
class Derived : public Base {
public:
void display() override { // Overriding the base class function
cout << “Derived class display function” << endl;
}
};
Example:
using namespace std;
class Animal {
public:
virtual void sound() {
cout << “Animal sound” << endl;
}
};
class Dog : public Animal {
public:
void sound() override {
cout << “Bark” << endl;
}
};
class Cat : public Animal {
public:
void sound() override {
cout << “Meow” << endl;
}
};
int main() {
Animal* animalPtr;
Dog dog;
Cat cat;
animalPtr = &dog;
animalPtr->sound(); // Output: Bark
animalPtr = &cat;
animalPtr->sound(); // Output: Meow
return 0;
}
Output:
Bark
Meow
- Explanation: The function sound() is overridden in both Dog and Cat Even though we are calling sound() using a pointer of type Animal*, the derived class’s function is called based on the object type. This is an example of runtime polymorphism enabled by function overriding.
4. Overloading vs Overriding
| Feature | Function Overloading | Function Overriding |
| Definition | Multiple functions with the same name but different parameters. | A function in a derived class with the same name and signature as a function in the base class. |
| Purpose | Provides different implementations based on different parameters. | Allows a derived class to provide a specific implementation of a base class function. |
| Binding | Compile-time binding (early binding). | Runtime binding (late binding). |
| Return Type | Can differ (does not affect overloading). | Must be the same as the base class function’s return type. |
| Virtual Keyword | Not needed. | Required to achieve dynamic dispatch in the base class. |
5. Best Practices for Function Overloading and Overriding
- Function Overloading:
- Overload functions only when the functions have conceptually related functionality.
- Make sure the function signatures are distinct to avoid confusion.
- Function Overriding:
- Always use the virtual keyword in base classes to ensure the proper function is called at runtime.
- Mark overridden functions with override to make the intent clear and catch errors at compile time.
- Avoid function overriding for private functions, as they cannot be accessed by derived classes.
6. Exercises and Hands-On Practice
- Exercise 1: Create a class Calculator that has overloaded functions add() for adding two integers, two doubles, and a string and an integer.
- Exercise 2: Implement a base class Employee with a function calculateSalary() and override it in derived classes FullTimeEmployee and PartTimeEmployee.
- Exercise 3: Define a class Shape with a virtual function area(), and override it in classes Circle and Rectangle. Use dynamic binding to calculate the area for different shapes.
7. Conclusion and Summary
- Function Overloading allows you to define multiple functions with the same name but different parameters, improving code readability and simplicity.
- Function Overriding provides the flexibility to redefine base class functions in derived classes, enabling runtime polymorphism and making your code more extensible.
- Both overloading and overriding play crucial roles in object-oriented programming and help create cleaner, more modular, and flexible C++ programs.
Assessment and Quizzes
- Quiz 1: Multiple-choice questions about the differences between function overloading and overriding.
- Quiz 2: Hands-on coding challenge where students create an overloaded function and override a base class function in a derived class.
Encapsulation and Data Hiding in C++
Module Overview:
In this module, we will explore Encapsulation and Data Hiding, two of the fundamental concepts in Object-Oriented Programming (OOP) in C++. These concepts help you design robust, maintainable, and secure applications by controlling how data and methods are accessed and modified. Encapsulation allows bundling data and methods together, while data hiding ensures that the internal state of an object is protected from unauthorized access.
1. What is Encapsulation?
- Definition: Encapsulation is the concept of wrapping the data (variables) and the methods (functions) that operate on the data into a single unit called a class. In other words, it refers to the bundling of data and the methods that manipulate the data into one entity, ensuring that the object’s internal state is protected and only accessible through well-defined interfaces.
- Why Use Encapsulation?
- Improves Maintainability: By grouping related data and functions together, your code becomes easier to maintain and understand.
- Enhances Flexibility: Changes in the internal workings of a class do not affect code outside the class, allowing you to change the implementation without affecting other parts of the program.
- Protects Data: Encapsulation helps prevent unintended interference and misuse of data by restricting direct access to it.
Basic Syntax of Encapsulation:
private:
double balance; // Private data members
public:
// Public member functions to access and modify the balance
void deposit(double amount) {
if(amount > 0)
balance += amount;
}
double getBalance() {
return balance;
}
};
Example:
using namespace std;
class Account {
private:
double balance;
public:
void deposit(double amount) {
if(amount > 0)
balance += amount;
}
void withdraw(double amount) {
if(amount <= balance) {
balance -= amount;
} else {
cout << “Insufficient funds!” << endl;
}
}
double getBalance() {
return balance;
}
};
int main() {
Account acc;
acc.deposit(500);
cout << “Balance: ” << acc.getBalance() << endl;
acc.withdraw(200);
cout << “Balance after withdrawal: ” << acc.getBalance() << endl;
acc.withdraw(400); // This should print “Insufficient funds!”
cout << “Final Balance: ” << acc.getBalance() << endl;
return 0;
}
Output:
Balance after withdrawal: 300
Insufficient funds!
Final Balance: 300
- Explanation:
- In the above example, the class Account encapsulates the balance data and provides public methods deposit(), withdraw(), and getBalance() to manipulate and access the balance. The balance is stored in a private variable, which ensures that direct modification of the balance from outside the class is not allowed. Access is only possible through public methods, enforcing controlled interactions with the data.
2. What is Data Hiding?
- Definition: Data Hiding is the concept of restricting access to the internal state of an object. By marking data members of a class as private or protected, we prevent external code from accessing or modifying the data directly. Instead, interactions with the data should happen through public member functions that define how the data should be accessed or modified.
- Why Use Data Hiding?
- Security: Protects an object’s state from unintended changes by outside code.
- Integrity: Ensures that data is manipulated only in appropriate ways, preserving the consistency and integrity of the object’s state.
- Encapsulation: Data hiding is a direct consequence of encapsulation and is one of its key principles.
Example of Data Hiding:
private:
string name; // Name is hidden from outside the class
int age; // Age is hidden from outside the class
public:
// Public methods to set and get private data
void setName(string n) {
name = n;
}
string getName() {
return name;
}
void setAge(int a) {
if (a >= 18) {
age = a;
} else {
cout << “Age must be 18 or older!” << endl;
}
}
int getAge() {
return age;
}
};
int main() {
Employee emp;
emp.setName(“John Doe”);
emp.setAge(30);
cout << “Employee Name: ” << emp.getName() << endl;
cout << “Employee Age: ” << emp.getAge() << endl;
emp.setAge(15); // Invalid age, should display error
return 0;
}
Output:
Employee Age: 30
Age must be 18 or older!
- Explanation:
- Here, the Employee class hides the internal data (name and age) by marking them as private. The class provides public methods to access and modify the data. If an invalid age (less than 18) is entered, the setAge() function ensures that the object’s state remains consistent by rejecting the invalid input.
3. Benefits of Encapsulation and Data Hiding
- Improved Code Modularity: By bundling related data and functions into a class, encapsulation enhances modularity. Each class becomes a self-contained unit of functionality.
- Easier Maintenance: With encapsulation, internal implementation changes do not affect other parts of the program. This makes the system easier to modify and maintain.
- Increased Reusability: Encapsulation allows you to create generalized classes that can be reused in different contexts, reducing code duplication.
- Better Control: Data hiding prevents direct access to class data, which enforces controlled interactions and ensures data integrity.
4. Access Specifiers
To implement data hiding and control access to class members, C++ uses access specifiers:
- Private: Members declared as private are accessible only within the class or by friends of the class.
- Public: Members declared as public are accessible from any part of the program.
- Protected: Members declared as protected are accessible by the class itself, derived classes, and friends of the class.
Example of Access Specifiers:
class Account {
private:
double balance; // Only accessible within the class
public:
void deposit(double amount) {
if (amount > 0)
balance += amount;
}
double getBalance() {
return balance;
}
};
5. Best Practices for Encapsulation and Data Hiding
- Use private data members: Always hide data members using the private access specifier and provide public setter and getter methods to access or modify them.
- Define getter and setter methods carefully: Ensure that the setter methods validate the input before modifying the internal state of the object.
- Limit access to critical data: Only expose the necessary data and functionality. Avoid exposing unnecessary internal details to the outside world.
- Use const-correctness: If a method does not modify the state of the object, declare it as const to ensure that it does not inadvertently change the data.
6. Exercises and Hands-On Practice
- Exercise 1: Create a class BankAccount with private data members like accountNumber and balance. Provide public methods to deposit, withdraw, and check the balance.
- Exercise 2: Implement a class Student with private members like name, age, and marks. Implement setter and getter methods, and ensure that marks cannot be set to an invalid value (e.g., negative marks).
- Exercise 3: Design a class Car with private data members for make, model, and year. Provide public methods to update and retrieve car details.
7. Conclusion and Summary
- Encapsulation allows you to bundle related data and methods together, enhancing code modularity, maintainability, and reusability.
- Data Hiding ensures that an object’s internal state is protected from unauthorized access, providing greater control and security over the data.
- Together, encapsulation and data hiding are powerful principles that help you write cleaner, safer, and more modular object-oriented code in C++.
Assessment and Quizzes
- Quiz 1: Multiple-choice questions to test the understanding of encapsulation and data hiding concepts.
- Quiz 2: Hands-on coding challenge where students are required to implement a class with private data members and public getter and setter methods.
