Classes, Structs, and Enums

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 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. Anyone looking for more thorough explanations or additional context should consider Chapters 3, 4, and 8 of that course.

Previous Course

Intro to Programming with C++

Starting from the fundamentals, become a C++ software engineer, step by step.

View Course

In C++, classes are created like this:

1class Character {
2  // Member Variable
3  int Health{100};
4
5  // Member Function (Method)
6  void TakeDamage(int Damage) {
7    Health -= Damage;
8  }
9}
10
11// Creating Objects from the class
12Character Frodo;
13

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 which keeps our class working as intended.

C++ has three access levels by default:

• public members are accessible 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

1class Character {
2  int a; // Private
3public:
4  int b; // Public
5  int c; // Public
6protected:
7  int d; // Protected
8private:
9  int e; // Private
10public:
11  int d; // Public
12};
13
14int main() {
15  Character Player;
16
17  // Not allowed - a is private
18  Player.a; 
19
20  // Allowed - b is public
21  Player.b;
22}
23

Where required, getters and setters can be implemented manually, allowing us to maintain class invariants like “the Health of a Character is never negative”:

1#include <iostream>
2
3class Character {
4public:
5  int GetHealth(){ return Health; }
6
7  void SetHealth(int NewValue){
8    if (NewValue < 0) {
9      Health = 0;
10    } else {
11      Health = NewValue;
12    }
13  }
14
15private:
16  int Health;
17};
18
19int main(){
20  Character Player;
21
22  // Not allowed - Health is private
23  // Player.Health = -10;
24
25  // Must use the setter
26  Player.SetHealth(-10);
27  std::cout << "Health: " << Player.GetHealth();
28}
29

1Health: 0
2

Inheritance

Our classes can inherit from other classes like this:

1class Character {};
2
3class Dragon : Character {};
4

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:

1class Character {};
2
3class Dragon : public Character {};
4

C++ supports multiple inheritance and abstract classes, both of which are covered later in this course.

Structs

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

1struct Vector3 {
2  float x; // Public
3  float y; // Public
4  float z; // Public
5};
6
7Vector3 MyPosition;
8

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 is one that 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:

1// Call the default constructor
2Vector MyVector;
3

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:

1struct Vector {
2  // Initialise all components to the same value
3  Vector(float Value) {
4    x = Value;
5    y = Value;
6    z = Value;
7  }
8  float x;
9  float y;
10  float z;
11};
12

Once we define any custom constructor, the implicit default constructor is no longer available:

1// Call custom constructor
2Vector MyVector{4.f};
3
4// Compilation error
5Vector AnotherVector;
6

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:

1struct Vector {
2  // A replacement default constructor
3  Vector() {
4    std::cout << "Constructing!" << std::endl;
5  }
6
7  // Initialise all components to the same value
8  Vector(float Value) {
9    x = Value;
10    y = Value;
11    z = Value;
12  }
13
14  // Construct from another vector and length
15  Vector(Vector OtherVector, float Length) {
16    // ...
17  }
18
19  float x;
20  float y;
21  float z;
22};
23
24Vector A;
25Vector B{1.4f};
26Vector C{B, 1.f};
27

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.

It looks like this:

1struct Vector {
2  Vector() :
3    // Member Initialiser List
4    x{1.f}, y{2.f}, z{3.f}
5  {
6    // Constructor Body
7    std::cout << "Constructing!";
8  }
9
10  float x;
11  float y;
12  float z;
13};
14

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

1struct Vector {
2  Vector(float x) :
3    // Member Initialiser List
4    x{x},
5    y{1.f + 2.f},
6    z{GetRandomFloat()}
7  {
8    // Constructor Body
9    std::cout << "Constructing!";
10  }
11
12  float x;
13  float y;
14  float z;
15};
16

Destructors

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

1struct Vector {
2  ~Vector() {
3    std::cout << "Destructing!";
4  }
5};
6

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:

1struct Vector {
2  float x;
3  float y;
4  float z;
5};
6

1Vector MyVector{1.1f, 5.8f, 2.f};
2

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:

1float x{MyVector.x};
2float y{MyVector.y};
3float z{MyVector.z};
4

We can instead do this:

1auto [x, y, z] { MyVector };
2

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

Enums

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

1enum class DamageType {
2  Fire,
3  Frost,
4  Arcane
5}
6

Access to the values is through the scope resolution operator:

1DamageType Weakness{DamageType::Fire};
2

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:

1using enum DamageType;
2
3DamageType Weakness{Fire};
4