values of uninitialized pointers in C

Question

suppose we have the following declarations in C :

double d[25], * p;
int * t;
char * c;

How can we explaine the following printf() results ?

printf("d : %x\t",d);
printf("p : %x\t",p);
printf("t : %x\t",t);
printf("c : %x\t",c);

which print the ligne :

d : 62fd30    p : 1    t : 0    c : 39

We can clairly see the memory adress of d but both p, t and c don't look like adresses. I used to think that a uninitialized pointer takes the Null value after its declaration. Am I wrong? how can we explain these results?

It cannot be explained, it's undefined behaviour. See https://stackoverflow.com/questions/11962457/ and https://stackoverflow.com/questions/4285895/ — flau, Mar 21 '19 at 13:30
The behaviour is undefined. You can explain it by looking at the generated assembly which will by no means be consistent with the code. — Bathsheba, Mar 21 '19 at 13:32
Aside: a pointer should be printed like this: `printf("p : %p\t", (void*)p);`. Using `%x` may happen to give the right value but not if `int` is 32 bits and a pointer is 64 bits. — Weather Vane, Mar 21 '19 at 13:32
I'm voting to close this question as off-topic because undefined behaviour cannot be explained. — Antti Haapala -- Слава Україні, Mar 21 '19 at 13:34
@WeatherVane Having *2* different UBs doesn't cancel each other... — Antti Haapala -- Слава Україні, Mar 21 '19 at 13:44
@AnttiHaapala that is why I wrote an "aside" which mentioned the right way to do it.. — Weather Vane, Mar 21 '19 at 13:47

Some programmer dude · Answer 1 · 2019-03-21T13:35:33.720

5

All automatic (non-static local) variables will by default be uninitialized with an indeterminate value (that can seem like random or garbage). It doesn't matter if the variable is a pointer or not.

Also, just reading the value of an uninitialized pointer isn't automatically UB (in C), but dereferencing an uninitialized pointer definitely is.

However, as mentioned in one comment, you need to use "%p" to print pointers (technically they need to be casted to void * as well). Mismatching printf format specifier and argument type do lead to UB.

edited Mar 21 '19 at 13:35

answered Mar 21 '19 at 13:32

Some programmer dude

400,186
35
402
621

3

Hm, in practice you are right, but in theory, reading the pointer could be UB (remember that trap-representation-thingie?) – Ctx Mar 21 '19 at 13:35
Use of an indeterminate value in a library function is UB too. – Antti Haapala -- Слава Україні Mar 21 '19 at 13:35
1

@Ctx True, but I doubt few of us will ever work on a system where pointers are not simple integers and can have trap values. :) – Some programmer dude Mar 21 '19 at 13:36
2

@Someprogrammerdude *few of us will ever work on a system where pointers are not simple integers* To be pedantic, there are probably [very, very few of us alive who **haven't**.](https://en.wikipedia.org/wiki/Real_mode) ;-) – Andrew Henle Mar 21 '19 at 14:00
1

@AndrewHenle Oh I completely repressed memories of that. Please excuse me while I go curl up crying in the shower... ;) – Some programmer dude Mar 21 '19 at 14:03

score 3 · Answer 2 · answered Mar 21 '19 at 13:35

3

You cannot assume any pointer will be zero-initialized after declaration - C standard does not imply anything at that point. Same goes with other types of values. This is why it is a good practice to set a value of a variable upon declaration, like:

int * t = NULL;

Some compilers do zero-initialize variables, but this is tool-specific feature.

answered Mar 21 '19 at 13:35

Diodacus

663
3
8

2

I would say, it is only good practice to initialize it, if there is a chance that this initialization value is indeed used somewhere. Otherwise, it is ugly code. – Ctx Mar 21 '19 at 13:38

Achal · Answer 3 · 2019-03-21T13:51:44.707

I used to think that a uninitialized pointer takes the Null value after its declaration. Am I wrong?

Yes, your assumption are incorrect. An uninitialized pointer declared with automatic storage always contains garbage or junk data i.e not a valid address, hence its better to initialize with NULL at first while declaring. For e.g

double *d = NULL;
/* some processing */
if(d == NULL) {
  /* @TODO error handling. Not allowed to de-reference NULL pointer */
}

Here

double d[25];
printf("d : %x\t",d);

d is an array of 25 double's & array name itself address, while printing d using %x causes undefined behavior, even your compiler could have warned you like this

main.c:5:19: warning: format specifies type 'unsigned int'but the argument has type 'double *' [-Wformat]

But you seems to ignore compiler warnings, one shouldn't. Always compiler your code with minimal flags like -Wall. For e.g

gcc -Wall -Werror -Wpedantic test.c

To print array name, use %p format specifier. for e.g

double d[25];
printf("Array d : %p\t",(void*)d);

Similarly with int pointer t and char pointer c, use %p format specifier instead of %x. Also don't keep any uninitialized pointer in your code.

int * t; /* initialized with valid address else 
            dereferencing uninitialized pointer causes UB */
printf("t : %p\n",(void*)t);

values of uninitialized pointers in C

3 Answers3