Null Pointers

Default-Initialized Pointers

When we created the array, all the pointers were default initialized.

Like primitive numeric types, default-initialized pointer variables have indeterminate values.

Every pointer variable contains an address, but it might not be an address that means anything!

In our example, we know that elephants[0] legitimately holds the address of an Elephant object (because we put one there), but we have no idea what address is stored in elephants[1].

If you had to guess…

In C++, we are never supposed to follow a default-initialized pointer. If we break the rules and do so, the result is undefined behavior—we can't know what will happen as a result. What will probably happen is that your program will try to access the memory at that location, and then,

• If that memory location is in a forbidden region (i.e., outside the memory space allocated to your program by the operating system), the program will crash with a segmentation fault (or similar error).
• If the memory location is still inside the space allocated to your program, your code will assume that it will find an Elephant there, and execute the getAge() function using whatever data is there.
  • Depending on what's actually in that memory location and what happens when your code treats it like an Elephant, your program might or might not crash.
  • If your program doesn't crash, it will probably return some integer value based on whatever was in memory. Which could be the correct value, in which case your program will probably appear to be running properly, or an incorrect value, which could cause problems later when another part of your program gets an unexpected result.

Key Point: Watch out for default-initialized pointers! If your program is crashing or behaving strangely, one thing to check is whether any pointers that are involved have been properly initialized.

Null Pointers

If you have an Elephant*, all you know is that it stores an address and it claims that there is an Elephant at that address.

Even default-initialized pointers store an address! And the stuff at that address is just bits, which could be an Elephant, for all you know.

There's no easy way for you to tell whether a pointer's value is the address of a real thing, or whether it is just pointing into space somewhere.

Pointer variables can store a special value, nullptr, which means “not a valid address”. We call a pointer with this value a null pointer.

The purpose of nullptr is to allow us to explicitly set a pointer variable to point to nowhere. Following a null pointer is also forbidden (because it doesn't point to anything), but it's much easier to avoid doing so by accident because we have a specific value to check against. Whenever we want to have a situation where sometimes there is a thing and sometimes there isn't, we can use a null pointer to represent the “there isn't” case, and check to see if a pointer is null before we try to use it.

Array of Elephants and Not-Elephants

So let's change our initialization to fill the array with null pointers to start with.

Elephant* elephants[10];
for (size_t i = 0; i < 10; ++i) {
    elephants[i] = nullptr;
}
elephants[0] = new Elephant{"Peanut", 2};

Now we can tell which pointers really point to Elephant objects, and which ones don't!

Let's suppose we want to pass pointers from the elephants array to printAge()…

void printAge(Elephant* e) {

}

Here's one possible implementation:

void printAge(const Elephant* e) {
    if (e != nullptr) {
        cout << e->getAge() << endl;
    } else {
        cout << "No elephant here!" << endl;
    }
}

int a[5]{1, 2};

Elephant* elephants[10]{nullptr};

Elephant* elephants[10]{};

(When logged in, completion status appears here.)