Setting private member pointer to the same class as NULL?

Question

I came across the following structure in a C++ library:

In myClass.h

class myClass {
public:
static myClass* Instance();
.
.
private:
static myClass* _instance;
.
.
};

---

and in myClass.cpp

myClass* myClass::_instance = NULL;

// followed by the all other functions..

myClass::myClass() {
    .
    .
}

myClass* myClass::Instance() {
    if (_instance == NULL) {
        .
        .
    }
    .
    .
}

---

So what is the use of making the _instance to be NULL pointer outside any function? And when is this line of code executed?

Thank you.

Edit: Adding the main function. And the instance function in myClass.cpp that checks for the value of the pointer. Still don't understand when the pointer get set to NULL though.

int _tmain(int argc, T_CHAR* argv[]) {

myClass* instance = myClass::Instance();

.
.
.

return 0;
}

Answer 1

I have stumbled upon something like this once. It was something similar to singleton. The reason (as explained by the person doing it) was that he specifically wanted to initialize instance at the first getInstance() function call and he wanted to make sure that the _instance pointer will be at first initialized to NULL (and not some garbage from memory) so that the check

if (_instance == NULL)

in the function works properly.

I am not sure this is the case here, but it's possible.

Answer 2

So what is the use of making the _instance to be NULL pointer outside any function?

Static data members usually have to be defined, in the namespace containing their class, in one source file; they are subject to the One Definition Rule, and so must have exactly one definition in any program that uses them. This is that definition.

Initialising it with NULL makes sure it's initially null, so that the Instance() function can determine whether the instance has been created yet. This isn't strictly necesssary since, like all static variables, it will be zero-initialised whether or not you explicitly provide an initialiser.

And when is this line of code executed?

During static initialisation, before any other code in the program; since it's a trivial type with a constant initialiser.

Answer 3

Static keyword means it is being shared by all the objects that will be instantiated by the class. Hence you need to initialize it outside any function.Static states that it is a class variable shared between all the instance of the class. It is opposite to instance variables, which each instance has its own copy. To access a class variable, there are two ways. 1) a_class::static_variable 2) a_class a; a.static_variable. The initialization must go in the source file (.cpp) rather than in the header. Because it is a static variable the compiler needs to create only one copy of it. If you don't, you get a link error. If that is in a header you will get a copy in every file that includes the header, so get multiply defined symbol errors from the linker.

Static data members are not part of objects of a given class type; they are separate objects. As a result, the declaration of a static data member is not considered a definition. The data member is declared in class scope, but definition is performed at file scope.

Answer 4

myClass* myClass::_instance = NULL;

the code attempts to initialize the static member variable.

Answer 5

It's an initialisation, ensuring that the pointer starts life with the value NULL from the very beginning of the program.¹

It gives the pointer an invalid, but recognisable and testable value before some useful pointer value is assigned to it later on during the program. This way, you can safely test the pointer to see whether it was yet given said useful value.

In this case, since you are showing a singleton, "later" means "when an instance of myClass is first requested" using some myClass::getInstancePlease() function that you have not shown.

It is more common to implement a singleton with a function-static instance, rather than a class-static pointer to some [probably dynamically-allocated] instance.

_{¹ As an object with static storage duration, it would do so anyway; therefore, this initialisation is actually completely pointless beyond documenting programmers' intent.}