Encapsulation

Designing a strong public interface

• Expose **intent** (withdraw) not storage details (balanceField).
• Keep methods that preserve invariants close to the data.
• Minimize public surface — fewer ways to misuse the class.
• Mark readers const; avoid unnecessary setters for immutable fields (e.g. id).

Encapsulation vs abstraction (quick)

• **Encapsulation:** how you hide and protect data + bundle with methods.
• **Abstraction:** showing essential features and hiding complexity (often via interfaces / abstract classes).
• They work together: encapsulate internals; abstract the useful view.

Friends and encapsulation

• friend can access private members — useful but **weakens** encapsulation.
• Use sparingly (e.g. tightly coupled helpers, operator<<). Prefer public APIs when possible.
• Details in the Friend Functions lesson.

Real-life encapsulated designs

• User with private password hash; public login / changePassword.
• Cart with private items; public add / remove / total.
• Battery with private percent; public charge / consume with clamps 0–100.
• Employee salary private; only HR methods adjust it with rules.

Student — private data + public API

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

class Student {
private:
    string name;
    int age;
public:
    void setData(string n, int a) {
        if (a > 0) { name = n; age = a; }
    }
    void display() const {
        cout << "Name: " << name << ", Age: " << age << "\n";
    }
};

int main() {
    Student s1;
    s1.setData("Ravi", 20);
    s1.display();
    return 0;
}

Account getters/setters with validation

#include <iostream>
using namespace std;

class Account {
private:
    double balance = 0;
public:
    double getBalance() const { return balance; }
    void setBalance(double b) { if (b >= 0) balance = b; }
    void deposit(double x) { if (x > 0) balance += x; }
};

int main() {
    Account a;
    a.setBalance(-10); // ignored
    a.setBalance(500);
    a.deposit(50);
    cout << a.getBalance() << "\n";
    return 0;
}

Withdraw preserves invariant

#include <iostream>
using namespace std;

class Wallet {
private:
    int money = 0;
public:
    void add(int x) { if (x > 0) money += x; }
    bool spend(int x) {
        if (x <= 0 || x > money) return false;
        money -= x;
        return true;
    }
    int get() const { return money; }
};

int main() {
    Wallet w;
    w.add(100);
    cout << w.spend(40) << " " << w.get() << "\n"; // 1 60
    cout << w.spend(100) << " " << w.get() << "\n"; // 0 60
    return 0;
}

Read-only id after construction

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

class User {
private:
    const int id;
    string name;
public:
    User(int i, string n) : id(i), name(n) {}
    int getId() const { return id; }
    string getName() const { return name; }
    void setName(string n) { if (!n.empty()) name = n; }
};

int main() {
    User u(7, "Neha");
    cout << u.getId() << " " << u.getName() << "\n";
    return 0;
}

Temperature clamp example

#include <iostream>
using namespace std;

class Dimmer {
private:
    int level = 0; // 0..100
public:
    bool setLevel(int v) {
        if (v < 0 || v > 100) return false;
        level = v;
        return true;
    }
    int getLevel() const { return level; }
};

int main() {
    Dimmer d;
    cout << d.setLevel(120) << "\n"; // 0
    d.setLevel(80);
    cout << d.getLevel() << "\n";
    return 0;
}

Public data vs encapsulated (contrast)

#include <iostream>
using namespace std;

struct OpenBox { int value; };

class SafeBox {
private:
    int value = 0;
public:
    void set(int v) { if (v >= 0) value = v; }
    int get() const { return value; }
};

int main() {
    OpenBox o; o.value = -5; // allowed but dubious
    SafeBox s; s.set(-5);    // rejected
    s.set(5);
    cout << o.value << " " << s.get() << "\n";
    return 0;
}