With all this in mind, let's look at an example class and see how we can extend it, just to see the syntax and as a first step.

First, we define a class to inherit from. This is no different from how we created any of our other classes. Take a look at this hypothetical Soldier class declaration:

class Soldier 
{ 
   private: 
      // How much damage can the soldier take 
      int m_Health; 
      int m_Armour; 
      int m_Range; 
      int m_ShotPower; 
       
    
   Public: 
      void setHealth(int h); 
      void setArmour(int a);   
      void setRange(int r); 
      void setShotPower(int p); 
}; 

In the previous code, we define a Soldier class. It has four private variables, m_Health, m_Armour, m_Range, and m_ShotPower. It has four public functions setHealth, setArmour, setRange, and setShotPower. We don't need to see the definition of the functions, they will simply initialize the appropriate variable that their name makes obvious.

We can also imagine that a fully implemented Soldier class would be much more in-depth than this. It would probably have functions such as shoot, goProne, and others. If we implemented a Soldier class in an SFML project, it would likely have a Sprite object, as well as an update and a getPostion function.

The simple scenario presented here is suitable for learning about inheritance. Now let's look at something new, actually inheriting from the Soldier class. Look at this code, especially the highlighted part:

class Sniper : public Soldier 
{ 
public: 
   // A constructor specific to Sniper 
   Sniper::Sniper(); 
}; 

By adding the : public Soldier code to the Sniper class declaration, Sniper inherits from Soldier. But what does this mean, exactly? Sniper is a Soldier. It has all the variables and functions of Soldier. Inheritance is more than this, however.

Notice also that in the previous code, we declare a Sniper constructor. This constructor is unique to Sniper. We have not only inherited from Soldier, we have extended  Soldier. All the functionality (definitions) of the Soldier class are handled by the Soldier class, but the definition of the Sniper constructor must be handled by the Sniper class.

This is what the hypothetical Sniper constructor definition might look like:

// In Sniper.cpp 
Sniper::Sniper() 
{ 
   setHealth(10); 
   setArmour(10);  
   setRange(1000); 
   setShotPower(100); 
} 

We could go ahead and write a bunch of other classes that are an extension of the Soldier class, perhaps Commando and Infantryman. Each would have the exact same variables and functions, but each could also have a unique constructor that initializes those variables appropriate to the type of Soldier. Commando might have very high m_Health and m_ShotPower but really puny m_Range. Infantryman might be in between Commando and Sniper, with mediocre values for each variable.

The terminology we might like to learn here is that the class that is extended from is the super-class, and the class that inherits from the super-class is the sub-class. We can also say parent and child class.

Did you say protected? Yes. There is an access specifier for class variables and functions called protected. You can think of protected variables as being somewhere between public and private. Here is a quick summary of access specifiers, along with more details about the protected specifier:

To fully understand what protected variables and functions are and how they can be useful, let's look at another topic first and then we can see them in action.