Encapsulation and Access Specifiers

We've now successfully abstracted our Monster objects into a class. This is keeping our code nice and organized.

The next step we want to consider is how we keep the objects of our classes in a valid state.

Class Invariants

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 :(

Encapsulation

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.

Public and Private Class Members

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 MyClass{
2  int VariableA; // private
3
4public:
5  int VariableB; // public
6  int VariableC; // public
7
8private:
9  int VariableD; // private
10
11public:
12  int VariableE; // public
13};

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}

Getters

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

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

Summary

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.

Preview: Constructors and Destructors

In the next lesson, we will delve into constructors and destructors in C++. Here’s what you can expect to learn:

• Understanding Constructors: Learn about constructors, special functions that are called when a new object is created. We will explore how they can be used to initialize objects.
• Implementing Different Types of Constructors: Discover the different types of constructors in C++, including default constructors and parameterized constructors.
• Destructors: Learn how to create functions within our class that are automatically called when our objects are destroyed.

Next Lesson

Constructors and Destructors

Learn about special functions we can add to our classes, control how our objects get created and destroyed.

ContinueView Course