Refactoring C++ Classes

When we write code, experiment and try different things to get our functionality to work, the solution we're left with isn't always optimal. It can be unneccessarily complex, or difficult to expand on in the future.

Refactoring is the process of taking code that already works, and improving it to make things simpler or more understandable.

Without constantly reviewing and refactoring our code to manage its complexity, the software we create quickly becomes limited.

If our functions and classes get too complex, it becomes increasingly difficult to add new features or fix bugs.

This can grind our project to a halt. To build more complex projects, we need to be able to manage that complexity. Good design, and proactive refactoring are how we do that.

When to Refactor

It is a lot easier to refactor code immediately after we have written it. At that point, it's still fresh in our memory, and we know exactly what the code is supposed to do.

Therefore, after we've created our new feature and confirmed it works as expected, we should review our code and see if we can improve it, before moving on.

In professional settings, this tends to be a required part of the process. We will ask other developers on the project to review our code and provide feedback before we merge it into the shared repository.

By restricting access to our classes in the way we did in the previous lesson, it also makes our code easier to refactor.

We know that other code is not going to be accessing the private parts of our class, so we are free to rewrite, delete and modify those as needed.

An Example

In the previous lesson, we might have left our class looking something like this:

1class Monster {
2public:
3  void SetHealth(int NewHealth) {
4    if (NewHealth <= 0) {
5      Health = 0;
6      isDead = true;
7    } else {
8      Health = NewHealth;
9      isDead = false;
10    }
11  }
12
13  bool GetIsDead() {
14    return isDead;
15  }
16
17private:
18  bool isDead { false };
19  int Health { 150 };
20};
21

A common first step to refactoring code is to ask ourselves if we can delete parts of it. For example, do we need to be storing and maintaining the private isDead boolean?

Because it's private, we know other code isn't accessing it - it's just being used in the GetIsDead function.

However, we can update that function to just use the Health value instead:

1bool GetIsDead() {
2  return Health <= 0;
3}
4

Now, we can remove the isDead variable from our class entirely. With the variable gone, we no longer need to maintain it in the existing TakeDamage function, nor in any future function we create. This keeps our code clean and simple.

1class Monster {
2public:
3  void SetHealth(int NewHealth) {
4    if (NewHealth <= 0) {
5      Health = 0;
6      isDead = true; // not needed
7    } else {
8      Health = NewHealth;
9      isDead = false;  // not needed
10    }
11  }
12
13  bool GetIsDead() {
14    return Health <= 0;
15  }
16
17private:
18  bool isDead { false };  // not needed
19  int Health { 150 };
20};
21

1bool isEnraged() {
2  bool isEnraged;
3  if (Health <= 0) {
4    isEnraged = false;
5  } else if (Health <= 200) {
6    isEnraged = true;
7  } else {
8    isEnraged = false;
9  }
10  return isEnraged;
11}
12

1bool isEnraged() {
2  if (Health <= 0) return false;
3  if (Health <= 200) return true;
4  return false;
5}
6

1bool isEnraged() {
2  isEnraged = Health >= 0 && Health <= 200;
3}
4

1bool isEnraged() {
2  return Health <= 200;
3}
4

This lesson introduced refactoring in a very simple context - refactoring a simple function. But, it is the concept that is important. We should constantly be asking questions about our code - just because our solution worked, that doesn't mean it was a good solution.

C++ Class Constructors

Restricting the ability for external code to change properties like Health has introduced another limitation to our class.

It is no longer possible to initialise monsters with different Health values. Whilst allowing other code to modify the Health of monsters in an uncontrolled way was problematic, we might still want to provide the ability to choose the initial Health value for our monsters.

We already know enough to make this happen. We could, for example, create a public function on our class. We could call this function something like Initialise, and have it accept an argument for the initial health value.

We could even apply what we've learned to make sure this function is only called once per object:

1class Monster {
2public:
3  void Initialise(int InitialHealth) {
4    if (isInitialised) return;
5    Health = InitialHealth;
6    isInitialised = true;
7  }
8
9private:
10  int Health { 150 };
11  bool isInitialised { false };
12};
13

But, so common is this requirement to set the initial values of class members, there is a special type of function specifically for this purpose. Constructors will be the topic of our next lesson!