Why cant an uninitialized pointer be explicitly assigned a value ?Why does it lead to segmentation fault ?

Question

int * p(void) 
{ 
int *x; 
*x=10; 
return (x); 
} 

We create *x, and dereference it before assigning anything to it (x). Most likely, when we are declaring something on the stack, it will have a random value. The assignment - *x = 10 will try to write the value 10 to whichever address the pointer is pointing to (i.e. the value of x itself) 
, so then what's the issue i.e. when we can assign a value 10 at some random location pointed by x so then why does this result in segmentation fault ?

Answer 1

Good one. You told everything perfectly and the only question remaining is "why can't we write to some random location in memory?". Well, that is due to OS protection. Suppose we write to a random location and changes the memory content of some other process, that can crash rt? So, OS allows a process to modify only the memory allowed by it- in Segmented memory managed systems, a process can only access the memory in its assigned segments and when it accesses a memory outside that it gets segmentation fault. 

In a uniprocess system this protection is not needed. One of the main uses of virtual memory in addition to extension of memory address space is this memory protection. 

Comments

Sir , just one confusion that when the OS doesn't allow to change the memory content of some random location then why are these uninitialized pointers assigned those random addresses ,?

---

You mean it is stupidity to assign those variables to pointer variables rt?

It indeed is and compiler or OS never do this. Actually 'garbage values' are never assigned to any variable. Variables are assigned some memory location and those locations may contain some left over stuff of previous usage- hence called garbage. So, when a pointer is created it gets a memory location and that location contains garbage- not that garbage is put by someone. We can of course clean this by assigning a practical value to pointer- but just assigning some valid pointer value also is useless as it might affect the logic of the code. Moreover it creates extra load.