Protected Class Members

In our earlier lesson on encapsulation, we saw how we can (and should) make some of the variables and functions of our class private.

Encapsulation and Access Specifiers

A guide to encapsulation, class invariants, and controlling data access with public and private specifiers.

This hides those functions and variables from the outside world. This makes our systems easier to design and use.

For example, we can create objects that allow the outside world to see our character's health, but not change it:

1class Character {
2public:
3  int GetHealth() { return mHealth; }
4
5private:
6  int mHealth { 100 };
7};

Access Restriction with Inheritance

An interesting problem arises when we're using inheritance in this context. Specifically, code in a derived class also can't access any inherited private members.

Below, we have a new class that inherits from Character, but this code also can't access the private mHealth variable:

1class Character {
2public:
3  int GetHealth() { return mHealth; }
4
5private:
6  int mHealth { 100 };
7};
8
9class Healer : public Character {
10public:
11  void Heal(int Amount) { mHealth += Amount; }
12};

1error: 'Character::mHealth': cannot access private
2member declared in class 'Character'

protected Members

Fortunately, we have an access level between public and private that solves this problem. This access level is called protected.

protected members cannot be accessed by functions that exist outside our class hierarchy, but they can still be accessed by code in child classes.

Below, we've changed mHealth to be protected rather than private:

1#include <iostream>
2using namespace std;
3
4class Character {
5public:
6  int GetHealth(){ return mHealth; }
7
8protected:
9  int mHealth{100};
10};
11
12class Healer : public Character {
13public:
14  void Heal(int Amount){ mHealth += Amount; }
15};
16
17int main(){
18  Healer Player;
19  cout << "Health: " << Player.GetHealth();
20
21  Player.Heal(50);
22  cout << "\nHealth: " << Player.GetHealth();
23}

1Health: 100
2Health: 150

Summary

We've now covered the three access levels we have in C++:

• private members are only accessible within the same class they are defined
• protected members are accessible within the same class, and any sub-class
• public members are accessible from anywhere

Next Lesson: Member Initializer Lists

In the next lesson, we'll explore Member Initializer Lists. Here's what we'll learn:

• Understanding Member Initializer Lists: Learn what member initializer lists are and how they differ from assignments in constructors.
• Why we would want to use them: Discover the three reasons why member initializer lists are preferred over equivalent code in a constructor body.
• Examples and Use Cases: See practical examples to illustrate the use of member initializer lists in various scenarios.

Free and Unlimited Access

Professional C++

Unlock the true power of C++ by mastering complex features, optimizing performance, and learning expert workflows used in professional development

View Course