Encapsulation and Access Specifiers

To make our classes useful, we generally want to establish some rules that users of our class can rely on.

For example, consider a simple class like this:

1class Monster {
2public:
3  int Health { 150 };
4};

It doesn't make sense for a Health value to be negative, so it would be useful to establish that as a rule that developers using our class can rely on.

A rule, such as "the Health of a Monster is never negative" is sometimes referred to as a class invariant.

We can attempt to set up the "Health is never negative" invariant by providing a TakeDamage() function that implements this rule:

1class Monster {
2public:
3  int Health { 150 };
4
5  void TakeDamage(int Damage) {
6    Health -= Damage;
7    if (Health < 0) { Health = 0; } 
8  };
9};

Our rule is now guaranteed if consumers only ever use the TakeDamage() function. But they can just bypass our rule by setting Health directly, so we're not done:

1#include <iostream>
2using namespace std;
3
4class Monster {
5public:
6  int Health{150};
7
Unchanged Code|Show
8  void TakeDamage(int Damage){/*...*/};
13}
14
15int main(){
16  Monster Goblin;
17  Goblin.Health -= 200;
18  cout << "Health: " << Goblin.Health << " :(";
19}

1Health: -50 :(

In programming, the process of encapsulation involves:

1. Bundling data and the functions that act on that data into the same object
2. Hiding the inner workings so consumers can only interact with the object in a controlled way

We have implemented the first step of encapsulation, by bundling our variables and functions into a class.

However, we have not implemented the second step. Consumers can see all the inner workings of our object.

This is making it unclear how they're supposed to use our object - "do I use TakeDamage() or do I modify Health?". And, as we've seen, the lack of encapsulation is making it impossible for us to implement our class invariants.

To express this in C++ terminology, we want to have part of our class be public and part of it to be private.

The parts of the class that we want external code to use will be public. This will be the friendly, external-facing interface.

The parts that we don't want people messing with will be private.

We saw in the class definition above, we already have the word public in our code:

1class Monster {
2public:
3  int Health { 150 };
4
Unchanged Code|Show
5  void TakeDamage(int Damage){/*...*/};
10};

In classes, all the members are private by default. What we were doing here was making everything public. Any code that creates a new object from our class can access and change everything on that object.

Let's update our class to introduce a private section, and move our Health variable there:

1class Monster {
2public:
Unchanged Code|Show
3  void TakeDamage(int Damage){/*...*/};
8
9private:
10  int Health { 150 };
11};

Private members of a class can still be modified by the functions of the class. Our class functions like TakeDamage() will be able to modify the Health value, but code outside our class will no longer have access to it.

Now, the public interface is very simple and protects users of our class from sneaking past our intended behavior

1Monster Goblin;
2Goblin.TakeDamage(50); // This is allowed
3Goblin.Health -= 50; // This isn't

1class Weapon {
2public:
3  int Damage{50};
4};
5
6int main(){
7  Weapon IronSword;
8  IronSword.Damage;
9  IronSword.Damage += 30;
10}

1class Weapon {
2private:
3  int Damage{50};
4};
5
6int main(){
7  Weapon IronSword;
8  IronSword.Damage;
9  IronSword.Damage += 30;
10}

After refactoring our previous class to move Health to the private section, we are now successfully implementing our class invariant. The Health of a Monster can never be negative.

But we've indirectly added more restrictions. Code outside our class can no longer tell how much Health our monsters have:

1#include <iostream>
2using namespace std;
3
4class Monster {
5public:
Unchanged Code|Show
6  void TakeDamage(int Damage){/*...*/};
11
12private:
13  int Health{150};
14};
15
16int main(){
17  Monster Goblin;
18  cout << "Health: " << Goblin.Health;
19}

1error: 'Monster::Health': cannot access
2private member declared in class 'Monster'

The typical approach for allowing external code access to our private members is to provide a simple function within the public part of our class.

A function like this is sometimes called a getter. Some programming languages offer a dedicated syntax for this, but C++ keeps it simple. We just create a function in the normal way:

1#include <iostream>
2using namespace std;
3
4class Monster {
5public:
6  int GetHealth() { return Health; }
7
Unchanged Code|Show
8  void TakeDamage(int Damage){/*...*/};
13
14private:
15  int Health{150};
16};
17
18int main(){
19  Monster Goblin;
20  cout << "Health: " << Goblin.GetHealth();
21}

1Health: 150

This allows outside code to see the current Health using the public GetHealth() function. But, they cannot change the Health, because the variable itself is still private.

1class Weapon {
2private:
3  int Damage { 50 };
4}
5
6Weapon IronSword;
7IronSword.Damage;

Setters have a similar purpose to getters except, predictably, they are functions that allow the outside world to update variables on our object.

The difference between making a setter available and just making the underlying variable public is that, with a setter being a function, we can control the process.

We can provide a setter for our Health variable, but in a way that maintains the invariant that the Health will never be negative:

1#include <iostream>
2using namespace std;
3
4class Monster {
5public:
6  int GetHealth(){ return Health; }
7
8  void SetHealth(int IncomingHealth){
9    if (IncomingHealth < 0) {
10      Health = 0;
11    } else {
12      Health = IncomingHealth;
13    }
14  }
15
Unchanged Code|Show
16  void TakeDamage(int Damage){/*...*/};
21
22private:
23  int Health{150};
24};
25
26int main(){
27  Monster Goblin;
28  cout << "Health: " << Goblin.GetHealth();
29  Goblin.SetHealth(-50);
30  cout << "\nHealth: " << Goblin.GetHealth();
31}

1Health: 150
2Health: 0

In this lesson, we explored the concept of encapsulation and its implementation in C++ using access modifiers. The key points include:

• Class Invariants: Establishing rules for class behavior that users can rely on. For instance, ensuring a Monster's health never goes negative.
• Encapsulation in C++: The process of bundling data and functions within a class and controlling how they are accessed and modified.
• Public and Private Access Modifiers: Using public and private keywords to control access to class members. Public members are accessible from outside the class, while private members are not.
• Implementing Class Invariants: Demonstrated by the TakeDamage function in the Monster class, ensuring health does not go negative.
• Getters and Setters: Functions that allow controlled access to private class members. Getters return the value of a private member, while setters allow modifying it under certain conditions.