Class Constructors

A constructor is a special type of function on a class. A constructor gets called automatically when an object of that class is created. Because of this, it is the ideal place to put any sort of initialisation.

To let C++ know that a function is a constructor, it needs to have two properties:

• It has the same name as the class itself. For example, if we have a Monster class, any function that is a constructor is also called Monster
• Constructors do not specify any return type (not even void)

We can see an example of a constructor below:

1class Monster {
2public:
3  Monster() {
4    Health = 150;
5  }
6
7  int GetHealth() { return Health; }
8
9private:
10  int Health;
11};
12

We should ensure that the constructors we create are in the public: section of our classes.

This will not be enforced by the compiler, as there are advanced scenarios where a non-public constructor is useful, but those are beyond the scope of this course. Therefore, for now, we just have to be mindful to always ensure our constructors are public.

1class Car {};
2

Using Constructors in C++ Classes

Above, we added a constructor to our class. As that constructor does not require any arguments, it is considered the default constructor.

This constructor will be called for us automatically, without making any changes to the code we had previously written. A simple Monster Harry; statement will cause this constructor to be called.

The following code will log out `"Ready for battle!"

1#include <iostream>
2using namespace std;
3
4class Monster {
5public:
6  Monster() {
7    cout << "Ready for battle!";
8  }
9};
10
11int main() {
12  Monster Harry;
13}
14

However, because constructors are functions, they can also accept arguments:

1class Monster {
2public:
3  Monster(int InitialHealth = 150) {
4    Health = InitialHealth;
5    cout << "Ready for battle!";
6  }
7
8  int GetHealth() { return Health; }
9
10private:
11  int Health;
12};
13

With this constructor's only argument being optional, it will still act as a default constructor. That means creating a Monster using the code Monster Harry; will still call this constructor.

However, we now have the ability to give our Monster objects an initial Health value when creating them.

Just like we were able to pass values to the int data type to set an initial value:

1int Level { 5 };
2

We can now do the same with our Monster data type

1// This still works
2Monster Harry;
3Harry.GetHealth(); // 150
4
5// We can now pass values to the constructor
6Monster Julia { 300 };
7Julia.GetHealth(); // 300
8

Class Constructors with Multiple Arguments

Like with any other function, constructors can have multiple arguments. For example:

1class Monster {
2public:
3  Monster(
4    int InitialHealth = 150,
5    bool isInitiallyEnraged = false
6  ) {
7    Health = InitialHealth;
8    isEnraged = isInitiallyEnraged;
9  }
10
11private:
12  int Health;
13  bool isEnraged;
14}
15
16// 150 health, not enraged
17Monster SmallCalmGoblin;
18
19// 300 health, enraged
20Monster BigAngryGoblin { 300, true };
21

Adding Multiple Constructors to C++ Classes

We can have multiple constructors in our classes. The only requirement is that each constructor must have sufficiently unique signatures.

For example, we can have a constructor that accepts a boolean, and a different one that accepts an integer.

In this example, we have 4 constructors:

1class Monster {
2public:
3  Monster() {
4    cout << "Using default constructor!";
5  }
6  
7  Monster(int InitialHealth) {
8    Health = InitialHealth;
9  }
10
11  Monster(bool isInitiallyEnraged) {
12    isEnraged = isInitiallyEnraged;
13  }
14  
15  Monster(int InitialHealth, bool isInitiallyEnraged) {
16    Health = InitialHealth;
17    isEnraged = isInitiallyEnraged;
18  }
19
20private:
21  int Health { 150 };
22  bool isEnraged { false };
23};
24
25// Uses first constructor
26Monster DefaultGoblin;
27
28// Uses second constructor
29Monster BigGoblin { 400 };
30
31// Uses third constructor
32Monster AngryGoblin { true };
33
34// Uses fourth constructor
35Monster BigAngryGoblin { 400, true };
36

As long as the parameter types are sufficiently unique, we can create as many constructors as we want.

The specific constraint is that, any time we create an object, it must be unambiguously clear which constructor is to be used.

That is, when the compiler receives a statement to create an object, there must be only one constructor that can handle the arguments that were provided in that statement.

This means that the following class would be problematic, as there are some argument combinations that could be handled by either constructor:

1class Monster {
2public:
3  Monster(int Level, int InitialHealth = 150) {
4    Level = Level;
5    Health = InitialHealth;
6  }
7
8  Monster(int InitialHealth) {
9    Health = InitialHealth;
10  }
11
12private:
13  int Level { 1 };
14  int Health { 150 };
15};
16

Whilst the above code would compile, issues can arise when we try to construct objects of that class. For example, were we to try to create a Monster in the following way:

1Monster Harry { 100 };
2

It is not clear which constructor to call - either could be used. We might be using the top constructor to set Level to 100, or the bottom constructor to set Health to 100.

Therefore, our code would not compile, with an error message such as "call to constructor of Monster is ambiguous".

1class Car {
2public:
3  Car(int Speed, int HorsePower, int Torque) {}
4  Car(int Speed, int HorsePower) {}
5  Car(int Speed) {}
6  Car(int Speed = 50) {}
7};
8
9Car A { 100, 200, 300 };
10Car B { 100, 200 };
11Car C { 100 };
12Car D;
13

Implementing Constructors Separately

In a previous lesson, we gave an example of how functions can be implemented outside of the body of the class, with the Monster::TakeDamage example. This also applies to constructors:

1class Monster {
2public:
3  // The prototype
4  Monster(int InitialHealth);
5
6private:
7  int Health { 150 };
8};
9
10// The implementation
11Monster::Monster(int InitialHealth) {
12  Health = InitialHealth;
13}
14

Destructors

In addition to constructors, our class can also define a destructor.

A destructor returns nothing, has no parameters, and has the same name as the class, but with a ~ prepended. We’ll see some exceptions later but, in almost all cases, a destructor should be public:

1class SomeClass {
2public:
3  // Destructor
4  ~SomeClass(){
5    // ...
6  }
7};
8

A destructor automatically runs when our objects are destroyed. This makes them the ideal place to do any cleanup we might need.

The object life cycle is something that will become more important as we learn more, and we’ll discover ways to control it. For now, we can note that the objects we’re creating are automatically destroyed when the scope they were created in is destroyed.

This means objects created in the global scope will be destroyed just before our program ends.

For objects created in a block scope, such as between the { and } of a function, the object will be destroyed when execution reaches the end of the block.

1#include <iostream>
2using namespace std;
3
4class Monster {
5public:
6  // Constructor
7  Monster(){
8    cout << "Monster Created" << endl;
9  }
10
11  // Destructor
12  ~Monster(){
13    cout << "Monster Destroyed" << endl;
14  }
15};
16
17void SomeFunction(){
18  Monster Goblin;
19}
20
21int main(){
22  cout << "Hello World" << endl;
23  SomeFunction();
24  cout << "Goodbye!";
25}
26

1Hello World
2Monster Created
3Monster Destroyed
4Goodbye!
5

Chapter Summary

In this chapter, we introduced the concept of classes. Classes are the main tool we use to implement the 4 key principles of object oriented programming. We also saw what the first two of those principles are:

Abstraction

Abstraction is the ability to group our objects into categories - conceptual models of what it means to be that type of thing. We grouped all individual monsters under the category, or class, of Monster.

The Monster class is the abstraction - each individual Monster object is an example, or an instance, of a Monster.

Encapsulation

We also looked at how we can use encapsulation to restrict access to parts of our objects, making them easier to use and maintain.

Encapsulation is the ability to hide implementation details under the hood.

Our objects expose only the controls that we intend to be used by external code - code that is not part of our class.

We make these things public. Implementation details - things the outside world doesn't need to know about, are made private.

Inheritance and Polymorphism

In the next chapter, we will finish out our initial exploration of object oriented programming by progressing our design further. We will encounter some new problems, and see how we can use the other two big ideas of object oriented programming.

Those principles are inheritance and polymorphism, and will allow us to create more and more complex software in an effective and organised way.