In this chapter, we will explain about the pattern and many arguments for and against it. We will describe how and why core systems within the Mach5 engine such as the Graphics Engine and Object Manager are utilized as Singletons. Finally, we will explain a number of different ways to implement this in C++, along with the pros and cons of each choice.

This chapter will be split into a number of topics. It will contain a simple step-by-step process from beginning to end. Here is the outline of our tasks:

When using an object-oriented programming language, one of the most important features included is the ability to hide data, preventing classes from accessing properties and functions of another class type by default. By using access specifiers such as public, private, and protected, we can dictate specifically how the data and/or functions can be accessed from other classes:

class ModifierExamples 
{ 
  public int publicInteger; 
  private void PrivateMethod() {} 
  protected float protectedNumber; 
};

A class can have unlimited variables or functions that are public, private, or protected and can even control access to entire sections of the class:

class MoreModifierExamples 
{ 
  public: 
    // until we reach another tag, all variables and functions  
    // will be public 
    int publicIntegar; 
    int anotherExample; 

  private: 
    // Now, they'll be private 
    void PrivateFunction() {} 
    double safeValue; 

  protected: 
    // And now...

Another thing that is important to know before diving into the Singleton pattern is what the static keyword means, as it's something that we will be using the functionality of when building this pattern. When we use the static keyword, there are three main contexts that it'll be used in:

#include <string> 

class StaticExamples 
{ 
public: 
  void InFunction() 
  { 
    static int enemyCount = 0; 

    // Increase the value of enemyCount 
    enemyCount += 10; 

    std::string toDisplay = "\n Value of enemyCount:  " +  
                std::to_string...

To reiterate, a global variable is a variable that is declared outside of a function or class. Doing this makes our variable accessible in every function, hence us calling it global. When being taught programming in school, we were often told that global variables are a bad thing or at least, that modifying global variables in a function is considered to be poor programming practice.

There are numerous reasons why using global variables is a bad idea:

The Singleton pattern in a nutshell is where you have a class that you can access anywhere within your project, due to the fact that only one object (instance) of that class is created (instantiated). The pattern provides a way for programmers to give access to a class's information globally by creating a single instance of an object in your game.

Whereas there are quite a few issues with using global variables, you can think of a Singleton as an improved global variable due to the fact that you cannot create more than one. With this in mind, the Singleton pattern is an attractive choice for classes that only have a unique instance in your game project, such as your graphics pipeline and input libraries, as having more than one of these in your projects doesn't make sense.

This single object uses a static variable and static functions to be able to access the object without having to pass it through all of our code.

In the Mach5 engine, Singletons are used for the application...

Another technique to add to your toolbox of programming concepts that we will use in the next section is the idea of templates. Templates are a way for you to be able to create generic classes that can be extended to have the same functionality for different datatypes. It's another form of abstraction, letting you define a base set of behavior for a class without knowing what type of data will be used on it. If you've used the STL before, you've already been using templates, perhaps without knowing it. That's why the list class can contain any kind of object.

Here's an example of a simple templated class:

#include <iostream> // std::cout 

template <class T> 
class TemplateExample 
{ 
public: 
  // Constructor 
  TemplateExample(); 
  // Destructor 
  ~TemplateExample(); 
  // Function 
  T TemplatedFunction(T); 
};

In this case, we created our TemplateExample class and it has three functions. The constructor and deconstructor look normal, but then I have...