Encapsulation and Abstraction in C++

# CHAPTER 19

Encapsulation and Abstraction #

1. Introduction #

2. Learning Objectives #

• Implement Encapsulation using private variables.

• Write Getter and Setter methods.

• Understand the concept of Data Hiding.

• Implement Abstraction using interfaces.

3. Encapsulation: Data Hiding #

class Player {
  public:
    int health; // BAD! Anyone can change this.
};

The Solution:

class Player {
  private:
    int health; // GOOD! Hidden from the outside.
};

4. Getters and Setters (Accessors and Mutators) #

#include <iostream>
using namespace std;

class Player {
  private:
    int health;

  public:
    // Constructor
    Player() { health = 100; }

    // GETTER: Returns the private data
    int getHealth() const {
        return health;
    }

    // SETTER: Modifies the private data WITH VALIDATION
    void setHealth(int newHealth) {
        if (newHealth < 0) {
            health = 0;
            cout << "Player is dead!" << endl;
        } else if (newHealth > 100) {
            health = 100; // Cap health at 100
        } else {
            health = newHealth;
        }
    }
};

int main() {
    Player p1;
    
    // p1.health = -50; // ERROR! Private!
    
    p1.setHealth(-50); // Setter catches the invalid input
    cout << "Current Health: " << p1.getHealth() << endl; // Uses getter
    
    return 0;
}

5. Abstraction in Practice #

In C++, true abstraction is achieved using Abstract Classes (classes with pure virtual functions) to act as Interfaces.

6. Creating an Interface #

// This acts as an Interface
class IShape {
  public:
    virtual double calculateArea() = 0;
    virtual double calculatePerimeter() = 0;
};

// Circle must implement ALL functions in the Interface
class Circle : public IShape {
  private:
    double radius;
  public:
    Circle(double r) : radius(r) {}
    
    double calculateArea() override {
        return 3.14159 * radius * radius;
    }
    
    double calculatePerimeter() override {
        return 2 * 3.14159 * radius;
    }
};

7. Why use Interfaces? #

8. Memory-Level Explanation #

9. Common Mistakes #

• Writing empty setters: A setter that just does health = newHealth; without any validation defeats the purpose of encapsulation. You might as well make the variable public.

• Not using const on getters: A getter shouldn't modify the object. Writing int getHealth() const { ... } ensures the compiler throws an error if you accidentally try to change health inside the getter.

10. Exercises #

1. 1. Create a BankAccount class with a private balance and a private password. Create a withdraw(double amount, string pass) method that only allows withdrawal if the password matches and the balance is sufficient.

1. 2. Create an IPlayable interface with play(), pause(), and stop() pure virtual functions. Implement it in a VideoPlayer class.

11. MCQ Quiz with Answers #

12. Interview Questions #

• Q: In C++, how do you enforce an interface contract on a class?

• Q: If you want a specific external function to access private variables without using getters, what C++ keyword can you use? (Answer: The friend keyword).

• Q: Explain the difference between Abstraction and Encapsulation.

13. Summary #

14. Next Chapter Recommendation #