Test for a null pointer value in C++

A pointer in C++ essentially contains an address to some memory location where you object or data is stored. In this case, a "NULL Pointer" is just an empty memory address. This is represented as a zero value. So to check it, you would write something like this:

SomeClass *someClassPointer = // ... call some method to get pointer

// Check for null pointer
if (someClassPointer == 0)
{
    // Pointer is null
}

This can be simplified by doing this:

if (someClassPointer)
{
    // For checking that the pointer is not null
}

if (!someClassPointer)
{
    // For checking that a pointer is null
}

Short answer: it depends.

Longer answer: First of all you can not compare a reference (if the type of myValue is something like T&) nor stack allocated objects (if myValue is just T) for null - these types are always allocated and not null (unless you screw up your stack or do other bad stuff - but you won't check for these cases, because than you will have bigger problems).

The only types you can check for null are pointers (myValue is something of type T*). For those types:

• if you use C++98, you can check against 0. NULL is usually just a macro (#define NULL 0).
• if you use the new C++11 there is a new nullptr keyword and you should check against this one.

Since 0 evaluates to false and anything else to true, you can also just use the pointer like a normal bool. A nullptr is of type nullptr_t and has operator bool() implemented - so you also can this one like you would use a bool.

In general: in C++98 the lack of nullptr is a source of errors, so if you can use C++11, ALWAYS use nullptr - never use NULL or 0 (int is just the wrong type to assign to a pointer or to compare with a pointer - if you have overladed methods you will run into problems since the compiler would use a method with an int parameter instead of a pointer type if it is suitable).

Let's assume you have two functions:

void foo(int a);

void foo(void *);

If you now call

foo(NULL);

the first function will get called (what probably is not what you want. So in C++11 you would write:

foo(nullptr);

while in C++98 you would have to write:

foo((void *)0);

This is one reason why the lack of null is/was a big issue before C++98. If you want to have something similar than in Objective-C, you could write the following function (for C++98):

template<typename T>
inline bool isNull(const T *obj) {
  return obj == ((const T *) 0);
}

// to use it:
if (isNull(myType)) { //myType is a pointer to something
  // some code
}

Although I never saw that one used in practice.

I hope this answer helps in understanding the concept in C++.

If i'm right, you want to check for null pointers. This is actually very easy in C++

Foo *pInstanc = new Foo;
if(pInstance)
{
    //do something with pInstance
}