Data
Abstraction and Encapsulation in C++
Data
Abstraction and Encapsulation are fundamental concepts in object-oriented
programming (OOP) that help manage complexity and enhance code reusability and
maintainability. Let’s explore each concept in detail with a C++ example.
Data Abstraction
Data
Abstraction refers to the concept of hiding the complex implementation details
of a system while exposing only the necessary and relevant features to the
user. In essence, it allows a programmer to focus on interactions with objects
without needing to understand their internal workings.
In C++,
data abstraction is achieved using abstract classes and interfaces. An abstract
class is a class that cannot be instantiated directly and typically contains at
least one pure virtual function.
Pure
Virtual Function:
A pure
virtual function is a function that is declared in a base class and must be
implemented by derived classes. It is specified by assigning `0` to the
function declaration.
Here’s an
example of data abstraction in C++:
Code
Example:
#include <iostream>
using namespace std;
// Abstract class with a pure virtual function
class Shape {
public:
// Pure virtual
function
virtual void
draw() const = 0;
// A regular
function
void
setColor(const string& color) {
this->color = color;
}
protected:
string color;
};
// Derived class that implements the pure virtual
function
class Circle : public Shape {
public:
void draw()
const override {
cout
<< "Drawing a circle with color: " << color <<
endl;
}
};
// Derived class that implements the pure virtual
function
class Rectangle : public Shape {
public:
void draw()
const override {
cout
<< "Drawing a rectangle with color: " << color <<
endl;
}
};
int main() {
// Shape shape;
// This would be an error as Shape is an abstract class
Circle circle;
circle.setColor("Red");
circle.draw(); // Output: Drawing
a circle with color: Red
Rectangle
rectangle;
rectangle.setColor("Blue");
rectangle.draw(); // Output:
Drawing a rectangle with color: Blue
return 0;
}
In this
example:
- The
`Shape` class is an abstract class with a pure virtual function `draw()`. This
hides the implementation details and allows derived classes to define specific
drawing behaviors.
- The
`Circle` and `Rectangle` classes are derived from `Shape` and provide
implementations for the `draw()` function.
- The
`main` function demonstrates how objects of `Circle` and `Rectangle` can be
used without knowing the specifics of their implementations.
Data
Encapsulation
Data
Encapsulation refers to the concept of bundling the data (variables) and
methods (functions) that operate on the data into a single unit, called a
class. It also involves restricting direct access to some of an object's
components, which is achieved through access specifiers such as `public`,
`protected`, and `private`.
Encapsulation
helps in:
-
Protecting the internal state of an object from unintended modifications.
-
Providing a controlled interface for interacting with the object.
In C++,
encapsulation is enforced using access specifiers:
-
`private`: Members declared as private are accessible only within the class.
-
`protected`: Members declared as protected are accessible within the class and
its derived classes.
-
`public`: Members declared as public are accessible from outside the class.
Here’s an
example of encapsulation in C++:
Code
Example:
#include <iostream>
using namespace std;
class BankAccount {
private:
double balance;
public:
BankAccount(double initial_balance) {
if (initial_balance > 0) {
balance = initial_balance;
} else {
balance = 0;
cout << "Initial balance
invalid." << endl;
}
}
void deposit(double amount) {
if (amount > 0) {
balance += amount;
} else {
cout << "Deposit amount
must be positive." << endl;
}
}
void withdraw(double amount) {
if (amount > 0 && amount
<= balance) {
balance -= amount;
} else {
cout << "Insufficient
funds or invalid amount." << endl;
}
}
double getBalance() const {
return balance;
}
};
int main() {
BankAccount account(1000.0);
account.deposit(500.0);
cout << "Balance after deposit:
$" << account.getBalance() << endl; // Output: Balance after deposit: $1500.0
account.withdraw(200.0);
cout << "Balance after
withdrawal: $" << account.getBalance() << endl; // Output: Balance after withdrawal: $1300.0
return 0;
}
In this
example:
- The
`BankAccount` class encapsulates the balance data with private access
specifier, making it inaccessible directly from outside the class.
- Methods
like `deposit()`, `withdraw()`, and `getBalance()` provide controlled access to
modify and view the balance.
- Direct
manipulation of the balance is restricted, ensuring that invalid or unintended
operations do not occur.
Summary
- Data
Abstraction simplifies interactions with complex systems by exposing only
necessary functionality through abstract classes and pure virtual functions.
- Data
Encapsulation protects and organizes data within a class, providing a
controlled interface for data manipulation and access.
Both
concepts are essential for writing robust and maintainable object-oriented
code, promoting better design and reliability in software development.
Hello, my name is G Krishna. I'm Creating this blog for the students who are beginners.
No comments:
Post a Comment