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 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.

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;

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.

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 f; // 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}

1error: 'Character::a': cannot access
2private 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":

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 instead:
26  Player.SetHealth(-10);
27  std::cout << "Health: " << Player.GetHealth();
28}

1Health: 0

Inheritance

Our classes can inherit from other classes like this:

1class Character {};
2
3class 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:

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

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;

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:

1// Call the default constructor
2Vector 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:

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};

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

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

1'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:

1struct Vector {
2  Vector() = default; 
3  // ...
4};

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:

1#include <iostream>
2
3struct Vector {
4  // The default constructor
5  Vector(){
6    std::cout << "Default Constructor\n";
7  }
8
9  // Initialise all components to the same value
10  Vector(float Value){
11    std::cout << "(float) Constructor\n";
12    x = Value;
13    y = Value;
14    z = Value;
15  }
16
17  // Construct from another vector and length
18  Vector(Vector OtherVector, float Length){
19    std::cout <<
20      "(Vector, float) Constructor\n";
21    // ...
22  }
23
24  float x;
25  float y;
26  float z;
27};
28
29int main(){
30  Vector A;
31  Vector B{1.4f};
32  Vector C{B, 1.f};
33}

1Default Constructor
2(float) Constructor
3(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:

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};

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};

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:

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

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

Destruction of objects, and the object life cycle more generally, is covered in detail in the advanced 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};

1Vector 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:

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

We can instead do this:

1auto [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:

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

Access to the values is through the scope resolution operator:

1DamageType 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:

1using enum DamageType;
2
3DamageType 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

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