(nil) value returned by int pointer in c

Question

when we declare a pointer it points to some random location or address in memory unless we explicitly assign a particular value(address of any variable) to it.

Here is code:

int *p;

printf("int is %p\n",p);

float *j;

printf("float is %p\n",j);

double *dp;

printf("double is %p\n",dp);

char   *ch ;

printf("char is %p\n",ch);

j=(float *)p;

printf("cast int to float %p\n",j);

output:

int is (nil)

float is 0x400460

double is 0x7fff9f0f1a20

char is (nil)

cast int to float (nil)

Rather than printing the random location it prints (nil)

what is (nil) here ?? I don't understand the behaviour of pointers here??

Yu Hao · Accepted Answer · 2014-11-16 05:56:17Z

2

Uninitialized pointer variables don't point to random address. Where they point is undefined.

In practice, they have the value what's left in the stack, which you can't know for sure. In your example, those several pointers happens to have 0 values, so they happen to be null pointer, and they print as nil.

Don't rely on such behavior, ever.

answered Nov 16, 2014 at 5:56

Yu Hao

123k50 gold badges253 silver badges305 bronze badges

Sign up to request clarification or add additional context in comments.

2 Comments

user4255847 Over a year ago

so it means the value stored in uninitialised pointer could be 0 or some random value left in stack

Yu Hao Over a year ago

@user4255847 They have undefined values, in particular, they are not random, let me say that again. Randomness have certain requirements.

janneb · Accepted Answer · 2014-11-16 07:54:30Z

1

If by the "gnu" tag you mean that you're using glibc, then the reason is that the printf implementation in glibc will print "(nil)" when encountering a NULL pointer.

In other words, several of your pointers happen to have the value NULL (0), because that's what happened to be on the stack at that particular location.

edited Nov 16, 2014 at 7:54

answered Nov 16, 2014 at 5:56

janneb

37.4k2 gold badges85 silver badges101 bronze badges

2 Comments

Keith Thompson Over a year ago

I wouldn't call it "protection". Printing a pointer value with %p doesn't dereference the pointer; the output is implementation-defined, but it's perfectly safe.

janneb Over a year ago

@KeithThompson: Fair enough. FWIW, IIRC glibc does have null ptr protection for cases where it has to dereference the pointer.

mchouhan · Accepted Answer · 2014-11-16 21:48:31Z

Elaborating on what @yu hao has said:

Whenever a subroutine is invoked, a stack frame is allocated to the subroutine. This frame exists until return statement is encountered.

A subroutine frequently needs memory space for storing the values of local variables, the variables that are known only within the active subroutine and do not retain values after it returns. For doing so , the compiler allocate space for this use by simply moving the top of the stack by enough to provide the space. This is very fast when compared to dynamic memory allocation, which uses the heap space. Note that each separate activation of a subroutine gets its own separate space in the stack for locals known as Stack Frames.

The main reason for doing this is to keep track of the point to which each active subroutine should return control when it finishes executing. An active subroutine is one that has been called but is yet to complete execution after which control should be handed back to the point of call. Such activations of subroutines may be nested to any level (recursive as a special case), hence the stack structure. If, for example, a subroutine DrawSquare calls a subroutine DrawLine from four different places, DrawLine must know where to return when its execution completes. To accomplish this, the address following the call instruction, the return address, is also pushed onto the call stack with each call.

Call Stack call stack 2

Coming back to your question, during its execution , the function can make changes to its stack frame and When a function 'returns', its frame is 'popped' from stack.
But the contents of stack remains unchanged in this process. Only the stack pointer gets modified to point to previous frame. So when a new subroutine gets called, new frame is allocated on top of previous one,and if the subroutine has uninitialized variables, they will print value that is stored in the memory allocated to them . Which will depend on the state of stack at that point of time.

Rizier123 · Accepted Answer · 2014-11-16 05:56:41Z

-1

All of your pointers are nil/ undefiend or the are just random values from the stack!

See: http://ideone.com/wwiy8F

answered Nov 16, 2014 at 5:56

Rizier123

59.8k17 gold badges106 silver badges167 bronze badges

Collectives™ on Stack Overflow

(nil) value returned by int pointer in c

4 Answers 4

2 Comments

2 Comments

Comments

Comments

Your Answer

Hot Network Questions

Collectives™ on Stack Overflow

4 Answers 4

2 Comments

2 Comments

Comments

Comments

Your Answer

Sign up or log in

Post as a guest

Related