C++ Encapsulation

What is Encapsulation?

Encapsulation is the OOP principle of hiding internal data and only exposing it through controlled public methods (getters and setters). It protects data integrity and reduces coupling.

#include <iostream>
#include <string>
using namespace std;

class User {
  private:
    string username;
    string password;
    int    loginAttempts;

  public:
    User(string u, string p) : username(u), password(p), loginAttempts(0) { }

    bool login(string pass) {
        if (loginAttempts >= 3) {
            cout << "Account locked!" << endl;
            return false;
        }
        if (pass == password) {
            loginAttempts = 0;
            cout << "Welcome, " << username << "!" << endl;
            return true;
        }
        loginAttempts++;
        cout << "Wrong password. Attempt " << loginAttempts << "/3" << endl;
        return false;
    }

    string getUsername() { return username; }
};

int main() {
    User u("alice", "secret123");
    u.login("wrong");
    u.login("secret123");
    return 0;
}

Output:

Wrong password. Attempt 1/3
Welcome, alice!

#include <iostream>
using namespace std;

class Counter {
  private:
    int count;
  public:
    Counter() : count(0) { }
    void increment()     { count++; }
    void decrement()     { if (count > 0) count--; }
    void reset()         { count = 0; }
    int  getCount()      { return count; }
};

int main() {
    Counter c;
    c.increment(); c.increment(); c.increment();
    cout << c.getCount() << endl;   // 3
    c.decrement();
    cout << c.getCount() << endl;   // 2
    c.reset();
    cout << c.getCount() << endl;   // 0
    return 0;
}

Summary

• Encapsulation = private data + public getters/setters.
• Prevents invalid state by validating input in setters.
• Reduces coupling — callers don't depend on internal implementation.