指针默认初始化值不为NULL？

Question

How do we know pointers are not initialized to NULL by default? There is a similar questions directed at Why aren't pointers initialized with NULL by default? Just for checking, here is a very simple code just to see if a pointer is set to NULL by default.

#include <iostream>
using namespace std;
int main()
{
    int* x;
    if(!x)
        cout << "nullptr" << endl;
    return 0;
}

and at the output, I received nullptr message. I appreciate if someone can clarify this.

Answer 1

How do we know pointers are not initialized to NULL by default?

Because we know that the standard says that default initialised pointer has an indeterminate value if it has automatic or dynamic storage. Quote from the standard (draft):

[dcl.init] If no initializer is specified for an object, the object is default-initialized. When storage for an object with automatic or dynamic storage duration is obtained, the object has an indeterminate value , and if no initialization is performed for the object, that object retains an indeterminate value until that value is replaced. ...

And further:

[dcl.init] To default-initialize an object of type T means:

— If T is a (possibly cv-qualified) class type [pointer isn't a class, so we don't care]

— If T is an array type [pointer isn't an array, so we don't care]

— Otherwise, no initialization is performed.

---

I have declared a char (and also int) pointer without initializing it , and I got null pointers.

Reading an indeterminate value has undefined behaviour. Quote from the standard (draft):

[dcl.init] ... If an indeterminate value is produced by an evaluation, the behavior is undefined except in the following cases: [cases which don't apply here]

Answer 2

The question you linked to handles variables with local storage duration exclusively, so I assume you refer to these as well.

Such variables are not initialised if you don't do so yourself, so they get the value of whatever was written in their memory location before (standard wording: their value is 'indeterminate') – nothing speaks against, though, that this memory already is zero – by pure accident!

You can try the following:

void test()
{
    int* p; // uninitialized
    std::cout << p << std::endl; // undefined behaviour!!!
    // (that's what you most likely did already...)

    // now something new: change the memory...
    p = reinterpret_cast<int*>(static_cast<uintptr_t(0xaddadaad));
}

int main()
{
    test();

    // again something new: call it a SECOND time:
    test();
}

As this is undefined behaviour there are no guarantees at all that you will get any meaningful output – chances are, though that the memory of first function call is reused in second one and you might get output ressembling to the following:

00000000
addadaad

So even if there just happened to be all zero memory at programme start, it might differ from that at some later point while your programme is running...