C++ Encapsulation

Hide the data, publish the rules

Encapsulation means the object owns its fields. Callers do not poke at them. They call methods. The class then decides what is allowed: a score cannot go below zero, a name cannot be empty, a tank cannot hold more than its capacity.

In C++ you do this with private data and public getters and setters. The previous chapter introduced access specifiers. This one is why they exist.

Private fields

Put data under private:. Code outside the class cannot read or write those names. Methods of the same class still can. That is the whole point: the class is the only place that touches the raw values.

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

class Player {
private:
  string name;
  int score;

public:
  Player(string n, int s) {
    name = n;
    score = s;
  }

  string getName() {
    return name;
  }

  int getScore() {
    return score;
  }
};

int main() {
  Player p("Ada", 12);
  cout << p.getName() << " has " << p.getScore() << endl;
  return 0;
}

p.score = -4; would not compile. The field is private. You must go through a method if you want to change it.

Getters

A getter returns a copy (or a const reference) of a field. Name them getX in this tutorial so the intent is obvious. They let the rest of the program read state without knowing how it is stored.

Later you can change score from an int to something else and keep the same getter. Callers do not notice.

Setters that protect invariants

A setter writes a field only when the new value is valid. If it is not, leave the old value or refuse the change. That is the rule living in one place instead of in every call site.

#include <iostream>
using namespace std;

class Score {
private:
  int value;

public:
  Score() {
    value = 0;
  }

  int get() {
    return value;
  }

  void add(int points) {
    if (points < 0) {
      return;
    }
    value += points;
  }
};

int main() {
  Score s;
  s.add(10);
  s.add(-3);
  cout << s.get() << endl;
  return 0;
}

The second add is ignored. The score stays 10. If value were public, a caller could set it to anything.

Public data skips the class

Structs with all-public fields are fine for bags of data with no rules. The moment a value has a legal range, make it a class and hide the field.

A tank that cannot overflow

Capacity is set in the constructor. fill never stores more than that. getLiters is the only way to read the current amount.

#include <iostream>
using namespace std;

class Tank {
private:
  int liters;
  int cap;

public:
  Tank(int capacity) {
    cap = capacity;
    liters = 0;
  }

  int getLiters() {
    return liters;
  }

  void fill(int amount) {
    if (amount < 0) {
      return;
    }
    liters += amount;
    if (liters > cap) {
      liters = cap;
    }
  }
};

int main() {
  Tank t(50);
  t.fill(40);
  t.fill(20);
  cout << t.getLiters() << endl;
  return 0;
}

Output is 50, not 60. The tank enforced its own limit.

What to keep private

• Anything that must stay consistent with something else (balance and transactions, size and buffer).
• Anything with a range or format (age, email, percentage).
• Helpers that are not part of the public story of the type.