Why encapsulation is required in C++ - See It in Action

Why Encapsulation is Required in C++

📖 Scenario: Imagine you are building a simple bank account system. You want to keep the account balance safe so that no one can change it directly by mistake. This is where encapsulation helps.

🎯 Goal: You will create a class called BankAccount that keeps the balance private. You will add methods to deposit money, withdraw money, and check the balance safely.

📋 What You'll Learn

Create a class BankAccount with a private variable balance of type double

Add a public method deposit that adds money to balance

Add a public method withdraw that subtracts money from balance only if there is enough money

Add a public method getBalance that returns the current balance

Demonstrate that balance cannot be accessed directly from outside the class

💡 Why This Matters

🌍 Real World

Banks and many software systems use encapsulation to protect sensitive data like account balances or personal information.

💼 Career

Understanding encapsulation is essential for writing safe and maintainable code in professional software development.

1

Create the BankAccount class with private balance

Create a class called BankAccount with a private variable balance of type double initialized to 0.0.

C++

class BankAccount {
private:
    double balance = 0.0;
};

// Your code here

Hint

Use private: to keep balance hidden from outside the class.

2

Add public methods to deposit and withdraw money

Add public methods deposit and withdraw to the BankAccount class. deposit should add a double amount to balance. withdraw should subtract amount from balance only if balance is enough.

C++

class BankAccount {
private:
    double balance = 0.0;
public:
    void deposit(double amount) {
        // Your code here
    }
    void withdraw(double amount) {
        // Your code here
    }
};

Hint

Use if to check if there is enough balance before withdrawing.

3

Add a method to get the current balance

Add a public method getBalance to the BankAccount class that returns the current balance as a double.

C++

class BankAccount {
private:
    double balance = 0.0;
public:
    void deposit(double amount) {
        balance += amount;
    }
    void withdraw(double amount) {
        if (balance >= amount) {
            balance -= amount;
        }
    }
    double getBalance() {
        // Your code here
    }
};

Hint

Return the private balance so outside code can see it safely.

4

Use the BankAccount class and show encapsulation

Create a BankAccount object called myAccount. Deposit 100.0, withdraw 30.0, then print the balance using getBalance(). Try to access balance directly (this should cause an error).

C++

int main() {
    BankAccount myAccount;
    // Your code here
    return 0;
}

Hint

Use myAccount.deposit(100.0); and myAccount.withdraw(30.0); then print myAccount.getBalance().

Practice

1. Why is encapsulation important in C++ programming?

easy

A. It hides the internal data to protect it from outside access.

B. It makes the program run faster by using less memory.

C. It allows multiple inheritance in classes.

D. It automatically generates user interfaces.

Solution

1. Step 1: Understand encapsulation concept

   Encapsulation means hiding internal data from outside code to protect it.

2. Step 2: Match with options

   It hides the internal data to protect it from outside access. correctly states that encapsulation hides data to protect it.

3. Final Answer:

   It hides the internal data to protect it from outside access. -> Option A

4. Quick Check:

   Encapsulation = Data protection [OK]

Hint: Encapsulation means hiding data safely [OK]

Common Mistakes:

• Confusing encapsulation with inheritance
• Thinking encapsulation improves speed
• Believing encapsulation creates UI automatically

2. Which of the following is the correct way to declare a private data member in a C++ class?

easy

A. private:
int data;

B. int private data;

C. private int data;

D. int data; private;

Solution

1. Step 1: Recall C++ private section syntax

   In C++, private members are declared under the keyword 'private:' followed by members.

2. Step 2: Check options for correct syntax

   private: int data; shows 'private:' followed by 'int data;', which is correct.

3. Final Answer:

   private: int data; -> Option A

4. Quick Check:

   Private members use 'private:' label [OK]

Hint: Private members go under 'private:' label [OK]

Common Mistakes:

• Placing 'private' before type incorrectly
• Using 'int private data;' which is invalid
• Putting 'private:' after member declaration

3. Consider this C++ class:

#include <iostream>
class Box {
private:
  int length;
public:
  void setLength(int len) { length = len; }
  int getLength() { return length; }
};

int main() {
  Box b;
  b.setLength(10);
  std::cout << b.getLength();
  return 0;
}

What is the output when this program runs?

medium

A. length

B. 10

C. 0

D. Compilation error

Solution

1. Step 1: Analyze setLength method call

   The method setLength(10) sets the private member length to 10.

2. Step 2: Analyze getLength output

   getLength() returns the value of length, which is now 10, so it prints 10.

3. Final Answer:

   10 -> Option B

4. Quick Check:

   Setter sets 10, getter returns 10 [OK]

Hint: Setter sets value, getter returns it [OK]

Common Mistakes:

• Expecting 'length' string output
• Thinking private member can't be accessed
• Assuming default value 0 is printed

4. What is wrong with this C++ code snippet related to encapsulation?

#include <iostream>
class Person {
private:
  int age;
public:
  void setAge(int a) { age = a; }
  int getAge() { return age; }
};

int main() {
  Person p;
  p.age = 25;
  std::cout << p.getAge();
  return 0;
}

medium

A. Getter method getAge() should be private.

B. Missing semicolon after class definition.

C. Direct access to private member 'age' is not allowed.

D. setAge method should return int.

Solution

1. Step 1: Identify access to private member

   The code tries to assign p.age = 25; but age is private, so direct access is illegal.

2. Step 2: Check other options

   Class ends with semicolon, getAge is public correctly, setAge can be void. So only direct access is wrong.

3. Final Answer:

   Direct access to private member 'age' is not allowed. -> Option C

4. Quick Check:

   Private members cannot be accessed directly [OK]

Hint: Private members can't be accessed outside class [OK]

Common Mistakes:

• Trying to access private data directly
• Thinking getter should be private
• Assuming setAge must return a value

5. You want to protect a class's data but still allow controlled access. Which encapsulation approach is best in C++?

hard

A. Make data protected and never provide any access functions.

B. Make data public and use comments to warn users not to change it.

C. Use global variables instead of class members.

D. Make data private and provide public getter and setter functions.

Solution

1. Step 1: Understand encapsulation goal

   Encapsulation protects data by hiding it and controlling access through functions.

2. Step 2: Evaluate options for best practice

   Make data private and provide public getter and setter functions. uses private data with public getter/setter, which is standard and safe.

3. Final Answer:

   Make data private and provide public getter and setter functions. -> Option D

4. Quick Check:

   Private data + public methods = Encapsulation [OK]

Hint: Private data + public methods = safe access [OK]

Common Mistakes:

• Making data public and trusting comments
• Using global variables instead of encapsulation
• Not providing any access to data