CODEWITHSUNDEEP
cpointersgcc
dj buen
dj buen

Reputation: 208

Pointers in C weird behavior inside a function

can someone explain this to me

main()
{
 int *x,y;
 *x = 1;
  y = *x;
 printf("%d",y);
}

when I compile it in gcc how come running this in main function is ok, while running it in different function wont work like the function below?

test()
{
 int *x,y;
 *x = 1;
  y = *x;
 printf("%d",y);
}

Upvotes: 3

Views: 199

Answers (3)

Jens
Jens

Reputation: 72619

Technically, in standardese, you invoke what is called undefined behavior due to using an uninitialized value (the value of the pointer x). What's going on under the hood is very likely this: your compiler allocates local variables on the stack. Calling functions likely changes the stack pointer, so different function's local variables are at different places on the stack. This in turn makes the value of the uninitialized x be whatever happens to be at that place in the current stack frame. This value can be different, depending on the depth of the chain of functions you called. The actual value can depend on a lot of things, e.g. back to the whole history of processes called before your program started. There's no point in speculating what the actual value might be and what kind of erroneous behavior might possibly ensue. In the C community we refer to undefined behaviour as even having the possibility to make demons fly out of your nose. It might even start WW3 (assuming appropriate hardware is installed).

Seriously, a C programmer worth her money will take extreme care not to invoke undefined behavior.

Upvotes: 3

moliad
moliad

Reputation: 1503

since x is a pointer, its not containing the int itself, it points to another memory location which holds that value.

I think you assume that declaring a pointer to a value also reserves memory for it... not in C.

If you made the above error in your code, maybe it would be good if I gave you a little bit more graphic representation of what is actually going on in the code... this is a common novice error. The explanation below might seem a bit verbose and basic, but it might help your brain "see" what is actually going on.

Let's begin... if [xxxx] is a value being stored in a few bits in the RAM, and [????] is an unknown value (in physical ram) you can say that that for X to be properly used it should be:

x == [xxxx]   ->   [xxxx]
x == address  of   a value (int)

when you write: *x=1 above, you are changing the value of an unknown area of RAM, so you are in fact doing:

x == [????]  -> [0001]    // address [????] is completely undefined !

In fact, we don't even know IF address [????] is allocated or accessible by your application (this is the undefined part), its possible the address points to anything. Function code, dll address, file handle structure... it all depends on the compiler/OS/application state, and can never be relied on.

so to be able to use a pointer to an int, we must first allocate memory for it, and assign the address of that memory to x, ex:

int y;   // allocate on the stack
x = &y;  // & operator means, *address* of"

or

x = malloc(sizeof(int));  // in 'heap' memory (often called dynamic memory allocation)

// here malloc() returns the *address* of a memory space which is at least large enough 
// to store an int, and is known to be reserved for your application.

at this point, we know that x holds a proper memory address so we'll just say it's currently set to [3948] (and contains an unknown value).

x == [3948]  ->  [????]

Using the * operator, you dereference the pointer address (i.e. look it up), to store a value AT that address.

*x = 1;

means: 

x == [3948]  ->  [0001]

I hope this helps

Upvotes: 2

Armen Tsirunyan
Armen Tsirunyan

Reputation: 132974

int *x,y;
*x = 1;

Undefined Behavior. x doesn't point to anything meaningful.

This will be correct:

int *x, y, z;
x = &z;
*x = 1;
y = *x;

or

int *x, y;
x = malloc(sizeof(int));
*x = 1;
y = *x;
//print
free(x);

Undefined behavior is, well, undefined. You can't know how it will behave. It can seem to work, crash, print unpredictable results and anything else. Or it can behave differently on different runs. Don't rely on undefined behavior

Upvotes: 12

Related Questions