Multiple Inheritance, Abstract Classes and Interfaces

Free, Unlimited Access

Comprehensive course covering advanced concepts, and how to use them on large-scale projects.

Professional C++





<Excerpt>


This lesson is a quick introductory tour of classes, structs, and enums within C++.  It is not intended for those who are entirely new to programming.  Rather, the people who may find it useful include:

- those who have completed our introductory course, but want a quick review
- those who are already familiar with programming in another language, but are new to C++
- those who have used C++ in the past, but would benefit from a refresher

It summarises several lessons from our introductory course.  Those looking for more thorough explanations or additional context should consider completing _**Chapters 3, 4, and 8**_ of that course.


</Excerpt>


<CoursePromo course="intro" />


In C++, classes are created like this:


```c++
class Character {
  // Member Variable
  int Health{100};

  // Member Function (Method)
  void TakeDamage(int Damage) {
    Health -= Damage;
  }
}

// Creating Objects from the class
Character Frodo;
```


## Access Specifiers


We can control how accessible class variables and methods are.  This allows us to have a “public” part of our objects - an interface which we expect other objects to interact with.


Meanwhile, we can restrict access to other methods and variables, ensuring they’re only available to internal code.  This makes our objects easier to use, and our classes simpler to create.


C++ has three access levels:

- `public` members are available to be called by any code that has access to one of our class instances
- `protected` members are only accessible to functions within the class, or any class that inherits from it. Inheritance is covered in the next section
- `private` members are only accessible to functions within the class

There can be any number of specifiers within a class.  Members have the accessibility defined by the closest proceeding specifier.


By default, class members are `private`.


```c++
class Character {
  int a; // Private
public:
  int b; // Public
  int c; // Public
protected:
  int d; // Protected
private:
  int e; // Private
public:
  int f; // Public
};

int main() {
  Character Player;

  // Not allowed - a is private
  Player.a; //<e>

  // Allowed - b is public
  Player.b;
}
```


```c++
//<o>
error: 'Character::a': cannot access
private member declared in class 'Character'
```


Where required, _**getters**_ and _**setters**_ can be implemented manually, allowing us to maintain class invariants like “_the_ _`Health`_ _of a_ _`Character`_ _is never negative_”:


```c++
#include <iostream>

class Character {
public:
  int GetHealth(){ return Health; }

  void SetHealth(int NewValue){
    if (NewValue < 0) {
      Health = 0;
    } else {
      Health = NewValue;
    }
  }

private:
  int Health;
};

int main(){
  Character Player;

  // Not allowed - Health is private
  // Player.Health = -10;

  // Must use the setter instead:
  Player.SetHealth(-10);
  std::cout << "Health: " << Player.GetHealth();
}
```


```c++
//<o>
Health: 0
```


## Inheritance


Our classes can inherit from other classes like this:


```c++
class Character {};

class Dragon : Character {};
```


Inheritance can also be private, protected, or public.  This sets the maximum access level of inherited members, ie:

- `public` inheritance lets inherited members maintain their original access level
- `protected` inheritance changes inherited `public` members to `protected`
- `private` inheritance makes all inherited members `private`

By default, C++ inheritance is `private`.  The most useful, and most similar to other programming languages, is public inheritance:


```c++
class Character {};

class Dragon : public Character {};
```


<Aside>


### Multiple Inheritance, Abstract Classes and Interfaces


C++ supports _**multiple inheritance**_ and _**abstract classes**_.


Pure virtual classes are also available, which cover similar use cases to _**interfaces**_ from other programming languages.


All three of these concepts are introduced later in this course


</Aside>


## Structs


In C++, structs are almost identical to classes.  The only difference is that by default, struct members are `public`


```c++
struct Vector3 {
  float x; // Public
  float y; // Public
  float z; // Public
};

Vector3 MyPosition;
```


Despite the similarities, by convention, we prefer to use classes for complex requirements and restrict our use of structs to simpler use cases.


For example, something requiring inheritance, references to other complex types, and lots of methods should probably be a `class`.  Something to hold a few primitive values together should probably be a `struct`.


## Constructors


Constructors are functions that are automatically called when we create objects from our classes and structs.


### Default Constructor


A default constructor does not require any arguments (ie, it does not have any parameters, or all of its parameters are optional)


Our classes come with an implicit default constructor, which is called when we write code like this:


```c++
// Call the default constructor
Vector MyVector;
```


### Custom Constructors


We can define custom constructors for our classes and structs by creating a member function with no return type, and the same name as our class or struct.  For example, a constructor for the `Vector` struct would also be called `Vector`:


```c++
struct Vector {
  // Initialise all components to the same value
  Vector(float Value) {
    x = Value;
    y = Value;
    z = Value;
  }
  float x;
  float y;
  float z;
};
```


Once we define any custom constructor, the implicit default constructor is deleted:


```c++
// Call custom constructor
Vector MyVector{4.0f};

// Compilation error
Vector AnotherVector;//<e>
```


```c++
//<o>
'Vector': no default constructor available
```


We can re-add it if desired, simply by providing a constructor that requires no arguments, or explicitly re-adding the default implementation using this syntax:


```c++
struct Vector {
  Vector() = default; //<h>
  // ...
};
```


In general, we can define as many constructors as we want, as long as their parameter lists are sufficiently unique such that the compiler knows which constructor we’re calling each time we initialize an object:


```c++
#include <iostream>

struct Vector {
  // The default constructor
  Vector(){
    std::cout << "Default Constructor\n";
  }

  // Initialise all components to the same value
  Vector(float Value){
    std::cout << "(float) Constructor\n";
    x = Value;
    y = Value;
    z = Value;
  }

  // Construct from another vector and length
  Vector(Vector OtherVector, float Length){
    std::cout <<
      "(Vector, float) Constructor\n";
    // ...
  }

  float x;
  float y;
  float z;
};

int main(){
  Vector A;
  Vector B{1.4f};
  Vector C{B, 1.f};
}
```


```c++
//<o>
Default Constructor
(float) Constructor
(Vector, float) Constructor
```


## Member Initialiser Lists


Where a constructor is initializing member variables, the preferred way of doing this is through a _**member initializer list**_.  This is a unique piece of syntax between our constructor heading and body.  We add a colon `:` followed by a list of comma-separated initializations.


Below, our constructor is initializing `x`, `y`, and `z` to `1.f`, `2.f`, and `3.f` using a member initializer list:


```c++
struct Vector {
  Vector() :
    // Member Initialiser List
    x{1.f}, y{2.f}, z{3.f}//<h>
  {
    // Constructor Body
    std::cout << "Constructing!";
  }

  float x;
  float y;
  float z;
};
```


Member initializer lists can use expressions, as well as constructor parameters:


```c++
struct Vector {
  Vector(float x) :
    // Member Initialiser List
    x{x},//<h>
    y{1.f + 2.f},//<h>
    z{GetRandomFloat()}//<h>
  {
    // Constructor Body
    std::cout << "Constructing!";
  }

  float x;
  float y;
  float z;
};
```


## Destructors


When we have code we need to run when an object is destroyed, our classes and structs can define a _**destructor**_.  A destructor uses the `~` symbol followed by the class/struct name:


```c++
struct Vector {
  ~Vector() {
    std::cout << "Destructing!";
  }
};
```


Destruction of objects, and the object life cycle more generally, is covered later in this course.


## Aggregate Initialisation


When all members of a class or struct are `public`, we can use aggregate initialization to provide values for those members when constructing an object:


```c++
struct Vector {
  float x;
  float y;
  float z;
};
```


```c++
Vector MyVector{1.1f, 5.8f, 2.f};
```


## Structured Binding


We can think of structured binding as aggregate initialization in reverse.  If we have an object, we can extract all its public members as variables in a single expression.  Rather than doing this:


```c++
float x{MyVector.x};
float y{MyVector.y};
float z{MyVector.z};
```


We can instead do this:


```c++
auto [x, y, z] { MyVector };
```


When using structured binding, we must use `auto` rather than specifying the variable types.


## Enums


In C++, enums are implemented in the following way:


```c++
enum class DamageType {
  Fire,
  Frost,
  Arcane
}
```


Access to the values is through the scope resolution operator:


```c++
DamageType Weakness{DamageType::Fire};
```


We can add a `using enum` statement if we want to reduce the need to qualify the enum name within the scope where the `using` statement is in effect:


```c++
using enum DamageType;

DamageType Weakness{Fire};
```


## Summary


Classes, structs, and enums are how we create custom types in C++. They allow you to encapsulate related data and functionality into reusable and modular components.  Key takeaways:

- Classes and structs are similar, but class members are private by default while struct members are public
- Access specifiers (public, protected, private) control the accessibility of class members
- Constructors are special member functions that initialize objects, and destructors clean up resources when objects are destroyed
- Inheritance allows classes to derive properties and behaviors from other classes
- Enums define a set of named constants and are useful for representing a fixed set of values

<FAQ>


```javascript
//<m>
{
  slug: 'when-to-use-classes-vs-structs',
  title: 'When to Use Classes vs Structs in C++',
  question: 'What are the key differences between classes and structs in C++, and when should I use one over the other?',
}
```


In C++, classes and structs are very similar - the only technical difference is that class members are private by default, while struct members are public by default. However, the convention is to use them in slightly different scenarios:


Use structs when you have a simple data type that:

- Mainly consists of public data members
- Has few (if any) member functions
- Doesn't need access control or inheritance

Examples include things like 2D/3D vectors, points, or color values.


Use classes for more complex types that:

- Require access control (public/protected/private)
- Have many member functions
- Use inheritance
- Need to maintain invariants or validate data

Examples include things like a `Player` class in a game, or a `Database` class.


So in summary, prefer structs for simple "Plain Old Data" (POD) types, and classes for more complex types that resemble real-world objects with behaviors.


</FAQ>


<FAQ>


```javascript
//<m>
{
  slug: 'constructors-with-same-name',
  title: 'Multiple Constructors with the Same Name',
  question: 'How can a class have multiple constructors with the same name?',
}
```


In C++, a class can have multiple constructors as long as they have different parameter lists. This is known as constructor overloading.


When you create an object, the compiler will choose the constructor that best matches the arguments you provide. For example:


```c++
#include <iostream>

class Player {
public:
  Player() {
    std::cout << "Default constructor\n";
  }

  Player(int health) {
    std::cout << "Int constructor\n";
  }

  Player(const std::string& name) {
    std::cout << "String constructor\n";
  }
};

int main() {
  Player p1;            // Default constructor
  Player p2{100};       // Int constructor
  Player p3{"Gandalf"}; // String constructor
}
```


```text
//<o>
Default constructor
Int constructor
String constructor
```


This allows for flexibility in how objects can be initialized. Just make sure each constructor has a unique signature (name + parameter list).


</FAQ>


<FAQ>


```javascript
//<m>
{
  slug: 'public-inheritance-use-cases',
  title: 'When to Use Public Inheritance',
  question: 'In what situations is it appropriate to use public inheritance in C++?',
}
```


Public inheritance is appropriate when there is an "is-a" relationship between the derived class and the base class.


For example, consider a game with a `Character` base class and derived classes representing player characters and non-player characters (NPCs).


We can say a `Player` "is a" `Character`, and an `NPC` "is a" `Character`. They share common attributes and behaviors that can be inherited from `Character`.


```c++
class Character {
public:
  void Move() {/*...*/ }
protected:
  int health_;
};

class Player : public Character {
public:
  void SpecialAbility() {/*...*/ }
};

class NPC : public Character {
public:
  void Dialogue() {/*...*/ }
};
```


Here, `Player` and `NPC` inherit the `Move()` function and `health_` member from `Character`, but also add their own unique functionality.


Public inheritance allows us to treat derived objects as if they were base objects. For example, we could have a `std::vector<Character*>` that stores pointers to both `Player` and `NPC` objects.


Use public inheritance when:

- The derived class "is a" specialization of the base
- You want the base class interface to be available to users of the derived class
- You want to be able to use derived objects in place of base objects

</FAQ>


<FAQ>


```javascript
//<m>
{
  slug: 'when-to-use-member-initializer-lists',
  title: 'When to Use Member Initializer Lists',
  question: 'What are the benefits of using member initializer lists in constructors?',
}
```


Member initializer lists provide several benefits over assigning values in the constructor body:

1. **Performance**: Initializing members in the initializer list directly constructs them with the provided values. Assigning values in the constructor body first default-constructs the members, then assigns to them. This can be less efficient, especially for complex types.
2. **Const and Reference Members**: Const and reference members MUST be initialized in the member initializer list, as they cannot be assigned to later.
3. **Clarity**: Initializer lists make it clear which arguments are being used to initialize which members. This can make the code more readable.

Here's an example:


```c++
#include <string>

class Player {
public:
  Player(const std::string& name, int health)
      : name_{name}, health_{health} {}//<h>

private:
  std::string name_;
  int health_;
};
```


Without the initializer list, we would have to write:


```c++
Player::Player(const std::string& name, int health) {
  name_ = name;
  health_ = health;
}
```


This is less efficient, as `name_` will be default-constructed first, then assigned to.


So prefer initializer lists, especially for const/reference members and complex types. Use assignment in the constructor body only when the initialization depends on some computation that can't be done in the initializer list.


</FAQ>


<FAQ>


```javascript
//<m>
{
  slug: 'default-constructors',
  title: 'Implicitly-Defined Default Constructors',
  question: 'When does the compiler implicitly define a default constructor for a class?',
}
```


In C++, a default constructor is a constructor that can be called with no arguments. The compiler will implicitly define a default constructor for a class if:

1. The class has no user-defined constructors at all.
2. All data members of the class have a default constructor (or are built-in types).

For example:


```c++
class Player {
  int health_;
  std::string name_;
};

Player p1; // OK, implicit default constructor
```


However, if we define any constructor for the class, the compiler will no longer provide an implicit default constructor:


```c++
class Player {
 public:
  Player(int health) : health_{health} {}

 private:
  int health_;
  std::string name_;
};

Player p1;       // Error, no default constructor//<e>
Player p2{100};  // OK, using defined constructor
```


In this case, if we still want a default constructor, we need to define it explicitly:


```c++
class Player {
 public:
  Player() = default;  //<h>
  Player(int health) : health_{health} {}

 private:
  int health_;
  std::string name_;
};

// OK, using defaulted default constructor
Player p1;
```


So remember: if you define any constructors for a class, and you want a default constructor, you need to define it explicitly (either by writing it or by using `= default`).


</FAQ>


<FAQ>


```javascript
//<m>
{
  slug: 'destructors-for-resource-management',
  title: 'Using Destructors for Resource Management',
  question: 'How can I use destructors to manage resources in C++?',
}
```


Destructors in C++ are responsible for cleaning up when an object is destroyed. This makes them ideal for managing resources that need to be acquired during an object's lifetime and released when the object is no longer needed.


For example, consider a class that manages a dynamically allocated buffer:


```c++
#include <cstddef>

class DynamicBuffer {
public:
  DynamicBuffer(std::size_t size)
    : data_{new int[size]}, size_{size} {}

  ~DynamicBuffer() {
    delete[] data_;//<h>
  }

private:
  int* data_;
  std::size_t size_;
};

int main() {
  {
    DynamicBuffer buf(1024);
    // Usee buf...
  }
  // buf is destroyed here, calling destructor
}
```


Here, the constructor allocates memory for the buffer, and the destructor ensures that this memory is freed when the `DynamicBuffer` object goes out of scope.


This technique is known as Resource Acquisition Is Initialization (RAII). The idea is that a resource (like memory, a file handle, a network connection, etc.) should be acquired in the constructor (during initialization) and released in the destructor. This way, we can't forget to release the resource, and we don't have to manually manage the object's lifetime.


Some key points about destructors:

- If you don't define a destructor, the compiler provides a default one (which does nothing).
- The destructor is called automatically when an object is destroyed, either because it went out of scope or because `delete` was called on a pointer to the object.
- Destructors don't take arguments and don't return a value.

So use destructors to clean up any resources that your object owns. This is a key part of writing safe, leak-free C++ code.


</FAQ>



A crash tour on how we can create custom types in C++ using classes, structs and enums

When to Use Classes vs Structs in C++

Multiple Constructors with the Same Name

When to Use Public Inheritance

When to Use Member Initializer Lists

Implicitly-Defined Default Constructors

Using Destructors for Resource Management

Updated references and added summary and FAQs

Added AI assistant, table of contents and references

Intro to C++

C++ class

C++ struct

C++ enum

struct

C++ Classes and Structs

C++ Structures

When should you use a class vs a struct in C++?

UPDATED FOR C++23 | Learn the fundamentals of creating custom types in C++ using classes, structs and enums. Covers access specifiers, inheritance, constructors and more | Clear explanations and simple code examples

Multiple Constructors with the Same Name

How can a class have multiple constructors with the same name?

Classes, Structs and Enums

What are the key differences between classes and structs in C++, and when should I use one over the other?

In what situations is it appropriate to use public inheritance in C++?

What are the benefits of using member initializer lists in constructors?

When does the compiler implicitly define a default constructor for a class?

How can I use destructors to manage resources in C++?

Classes, Structs and Enums

Professional C++

This course includes:

Professional C++