Encapsulation best practices in C++ - Step-by-Step Execution

Concept Flow - Encapsulation best practices

Define class with private data

↓

Provide public methods to access data

↓

Use methods to get/set data safely

↓

Prevent direct access to internal data

↓

Maintain control and data integrity

Encapsulation means hiding data inside a class and controlling access through public methods to keep data safe and consistent.

Execution Sample

C++

class BankAccount {
private:
    double balance = 0;
public:
    void deposit(double amount) { if(amount > 0) balance += amount; }
    double getBalance() { return balance; }
};

This code shows a class hiding its balance and allowing safe deposit and balance check.

Execution Table

Step	Action	Condition	Result	Balance
1	Create BankAccount object	-	balance initialized (default 0)	0
2	Call deposit(100)	100 > 0	balance updated to 100	100
3	Call deposit(-50)	-50 > 0	condition false, no change	100
4	Call getBalance()	-	returns 100	100
5	Try direct access to balance	Not allowed (private)	compile error	100

💡 Direct access to balance is blocked by private keyword, ensuring encapsulation.

Variable Tracker

Variable	Start	After Step 2	After Step 3	Final
balance	0	100	100	100

Key Moments - 3 Insights

Why can't we access 'balance' directly from outside the class?

Because 'balance' is private, only class methods can access it, as shown in step 5 of execution_table where direct access causes a compile error.

What happens if we try to deposit a negative amount?

The deposit method checks if amount > 0 (step 3), and if false, it does not change balance, keeping data safe.

How do public methods help maintain data integrity?

Public methods like deposit control how balance changes, preventing invalid states, as seen in steps 2 and 3.

Visual Quiz - 3 Questions

Look at the execution_table, what is the balance after step 3?

A 50

B 100

C 0

D -50

💡 Hint

Check the 'Balance' column in row for step 3 where deposit(-50) is called.

At which step does the program prevent invalid data modification?

A Step 3

B Step 4

C Step 2

D Step 5

💡 Hint

Look at the 'Condition' and 'Result' columns for step 3 in execution_table.

If 'balance' was public, what would change in the execution_table?

A Step 3 condition would change

B Step 2 would fail

C Step 5 would succeed without error

D Step 4 would return zero

💡 Hint

Refer to step 5 where direct access is blocked due to 'private' keyword.

Concept Snapshot

Encapsulation hides data inside classes using private members.
Access data only through public methods.
This protects data from invalid changes.
Use checks in methods to keep data valid.
Prevents bugs and keeps code safe.

Full Transcript

Encapsulation is a way to keep data safe inside a class by making it private. We use public methods to access or change this data. For example, a BankAccount class hides its balance variable. You can only add money using the deposit method, which checks if the amount is positive. Trying to access balance directly from outside the class causes an error. This way, the class controls how data changes and stays correct. The execution table shows each step: creating the object, depositing money, rejecting invalid deposits, checking balance, and blocking direct access. This helps beginners see how encapsulation protects data and why it is important.

Practice

1. What is the main purpose of encapsulation in C++?

easy

A. To make the program run faster

B. To hide data and protect it from unauthorized access

C. To allow direct access to all class members

D. To increase the size of the program

Solution

1. Step 1: Understand encapsulation concept

   Encapsulation means hiding the internal details of a class to protect data.

2. Step 2: Identify the main goal

   The goal is to prevent wrong or unauthorized changes by restricting direct access.

3. Final Answer:

   To hide data and protect it from unauthorized access -> Option B

4. Quick Check:

   Encapsulation = Data protection [OK]

Hint: Encapsulation means hiding data safely [OK]

Common Mistakes:

• Thinking encapsulation speeds up code
• Believing all data should be public
• Confusing encapsulation with inheritance

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

easy

A. private: int age;

B. int age; // private by default

C. protected int age;

D. public int age;

Solution

1. Step 1: Recall C++ access specifiers

   Private members must be declared after the keyword 'private:' in a class.

2. Step 2: Check each option

   private: int age; uses 'private:' correctly before 'int age;'. Others are either public, protected, or missing specifier.

3. Final Answer:

   private: int age; -> Option A

4. Quick Check:

   Private members use 'private:' label [OK]

Hint: Use 'private:' label before private members [OK]

Common Mistakes:

• Assuming members are private by default
• Using 'private' without colon
• Declaring private members as public

3. What will be the output of this C++ code?

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;
}

medium

A. 0

B. Compilation error

C. 10

D. Garbage value

Solution

1. Step 1: Understand class methods

   The method setLength sets the private member length to 10.

2. Step 2: Check output statement

   getLength returns length, which was set to 10, so output is 10.

3. Final Answer:

   10 -> Option C

4. Quick Check:

   Setter sets 10, getter returns 10 [OK]

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

Common Mistakes:

• Expecting default 0 without setting
• Thinking private members can't be accessed via methods
• Confusing compilation error due to private member

4. Identify the error in this C++ class related to encapsulation:

class Person {
public:
    int age;
    void setAge(int a) { age = a; }
    int getAge() { return age; }
};

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

medium

A. Age should be private to prevent invalid values

B. setAge method is missing return type

C. getAge should be private

D. No error, code is correct

Solution

1. Step 1: Check data member access

   Age is public, so it can be set directly to invalid value -5.

2. Step 2: Understand encapsulation best practice

   Age should be private and setAge should validate input to prevent invalid values.

3. Final Answer:

   Age should be private to prevent invalid values -> Option A

4. Quick Check:

   Private data prevents invalid direct changes [OK]

Hint: Make data private to control changes [OK]

Common Mistakes:

• Thinking public data is safe
• Believing getters should be private
• Ignoring validation in setters

5. You want to protect a class's data member balance so it cannot be set to a negative value. Which is the best encapsulation practice to achieve this?

hard

A. Make balance public and check value outside the class

B. Make balance protected and allow derived classes to set it freely

C. Remove balance and use a global variable instead

D. Make balance private and provide a setter that validates input

Solution

1. Step 1: Understand data protection need

   To prevent negative values, direct access must be blocked.

2. Step 2: Use private data with validation

   Making balance private and using a setter method to check values ensures safety.

3. Final Answer:

   Make balance private and provide a setter that validates input -> Option D

4. Quick Check:

   Private data + validated setter = safe encapsulation [OK]

Hint: Use private data and validate in setter [OK]

Common Mistakes:

• Leaving data public for easy access
• Using protected without validation
• Using global variables for encapsulation