An important feature of C++ classes and structures is “inheritance,” which works very similarly to how it sounds. Essentially, classes can “inherit” functionality from other classes, just as humans can inherit characteristics from their parents. A common example of inheritance in programming is with shapes:
#include <iostream> class Quadrilateral { public: int numberOfSides = 4; }; class Square : public Quadrilateral { private: int length; public: Square(int length) { this->length = length; } int getArea() { return length * length; } }; class Rectangle : public Quadrilateral { private: int width; int height; public: Rectangle(int width, int height) { this->width = width; this->height = height; } int getArea() { return width * height; } }; int main() { Square square(5); std::cout << "A square has " << square.numberOfSides << " sides.\n"; std::cout << "Square area: " << square.getArea() << "\n\n"; Rectangle rectangle(3, 6); std::cout << "A rectangle has " << rectangle.numberOfSides << " sides.\n"; std::cout << "Rectangle area: " << rectangle.getArea() << "\n"; return 0; }
Program output:
A square has 4 sides. Square area: 25 A rectangle has 4 sides. Rectangle area: 18
A “derived” class (Rectangle
and Square
in the code above) can inherit from a “base” class (Quadrilateral
) when we put a colon after the derived class name followed by an access modifier and the base class name.
When a derived class inherits from a base class, we say that the derived class is a base class. For example, a Rectangle
is a Quadrilateral
and a Square
is a Quadrilateral
. A derived class contains all code from its base class (with some exceptions that we’ll talk about when going over access modifiers). This means that the Square
and Rectangle
classes in the sample program both have their own numberOfSides
variable that’s equal to 4.
Inheritance is useful when multiple classes share some set of variables and functions. Rather than copying and pasting those variables/functions into each class that uses them, they can be placed into just one base class. In the sample program, the numberOfSides
variable could be placed into each of its derived classes, but it’s easier to only write it once (in the Quadrilateral
class).
Here’s a visualization of this program’s class hierarchy:

Access Modifiers
Recall that public variables/functions in a class are accessible outside of their class, while private variables/functions are not. Variables and functions can also be protected, meaning that they’re only accessible to derived classes.
Access modifiers are also used to represent different types of inheritance when placed before base class names. In the above sample program, both the Square
class and the Rectangle
class follow public inheritance because of “ : public Quadrilateral
“. Inheritance can also be protected or private.
The access modifier used for inheritance determines the access level of variables and functions in the base class. Most likely, you’ll almost always use public inheritance, but here are some tables that show the effects of each type of inheritance:
Public Inheritance
Access Level in Base Class | Access Level in Derived Class |
Private | Inaccessible |
Protected | Protected |
Public | Public |
- The derived class cannot access any private variables/functions in the base class.
- Any protected variables/functions in the base class are protected for the derived class.
- Any public variables/functions in the base class are public for the derived class.
Protected Inheritance
Access Level in Base Class | Access Level in Derived Class |
Private | Inaccessible |
Protected | Protected |
Public | Protected |
- The derived class cannot access any private variables/functions in the base class.
- Any protected variables/functions in the base class are protected for the derived class.
- Any public variables/functions in the base class are protected for the derived class.
Private Inheritance
Access Level in Base Class | Access Level in Derived Class |
Private | Inaccessible |
Protected | Private |
Public | Private |
- The derived class cannot access any private variables/functions in the base class.
- Any protected variables/functions in the base class are private for the derived class.
- Any public variables/functions in the base class are private for the derived class.
Calling a Base Class Constructor
Whenever the constructor of a derived class runs, it also runs the default constructor of the base class, automatically. However, you may sometimes want to call a non-default base class constructor (one that has parameters). This can be done in the derived class’s initializer list:
#include <iostream> class Quadrilateral { public: int numberOfSides = 4; }; class Rectangle : public Quadrilateral { protected: int width; int height; public: Rectangle(int width, int height) { this->width = width; this->height = height; } int getArea() { return width * height; } }; class Square : public Rectangle { public: Square(int length) : Rectangle(length, length) {} }; int main() { Square square(5); std::cout << "A square has " << square.numberOfSides << " sides.\n"; std::cout << "Square area: " << square.getArea() << "\n\n"; Rectangle rectangle(3, 6); std::cout << "A rectangle has " << rectangle.numberOfSides << " sides.\n"; std::cout << "Rectangle area: " << rectangle.getArea() << "\n"; return 0; }
This program does the same thing as the first, except it follows a different inheritance structure. Now, the Rectangle
class inherits from the Quadrilateral
class, and the Square
class inherits from the Rectangle
class. (A rectangle is a quadrilateral, and a square is a rectangle). The class hierarchy looks like this:

You can see that we got rid of more repetitive code by just using the rectangle’s getArea
function for getting the area of a square. This works because, in the Square
constructor, we call the constructor for the Rectangle
class, setting its width and height both equal to the side length of the square. Then, when doing square.getArea()
, the rectangle’s getArea
function returns the product of its width (5) and height (5).
Notice how the Rectangle
class’s width
and height
variables are now “protected.” This allows the Square
class to access those variables if ever needed.