Question

Why can’t we initialize a pointer variable with user defined input?

Answer 1

You can initialize a pointer at the global scope to any value which is either a constant expression, or resolvable by the linker. This is because the C compiler places constants direct into the initialization code. Referenced symbols are also placed into the initialization code, and the linker replaces those symbols by the real address values.

// global scope
int foo;
int* bar = &foo; // ok, since &foo is a known address
int* bar2 = &foo+1; /* ok, since &foo is a known
            address and the offset is constant. */
int* whatever = (int*) 0xabcd; /* Ok, since 0xabcd is
                a constant value, and can be used as
                an address, but it depends on your
                environment if this address makes any
                sense */
int *baz = bar; /* not OK, since the value of bar is
                   stored into the RAM at run time,
                   and the linker can't determine that
                   this value does point to &foo */

In a function you can initialize any non-static pointer variable to a value which is already there. This is because these initializations work like normal variable assignments.

Edit: The illegal int *baz = bar; part

Disclaimer: I describe the behavior of typical compiler+linker toolchains seen on windows, Linux and *BSD, in the embedded world the initalization can look very different.

All initializations of variables on the global level are put into an own data segment in the executable file, and are copied at the program start into the RAM. This means that the linker must create this sections by collecting all global variables, and resolving symbol references in this section. The linker can only resolve values which contain link-time constant values only, which are addresses and numeric constants. The int *baz = bar; statement does use an indirect value, bar. While bar can be resolved to &foo in this specific case, the compiler does not care, since the standard requires that this is an assignment ofbaz with the runtime memory content of bar. And since such runtime memory references are not available to the linker, since the linker can’t run the program, the compiler reject to generate code for this statement.

Also changing the type of bar from int* bar to int* const bar does not help, because also a constant does have a memory region, and the C compiler must act as if it uses this memory region when the values is used somewhere. This means that even when it is clear which value bar does have, the compiler can’t place the constant value into object code, since the standard requires that the runtime memory is used to determine the value of bar when it is used.

As a side note, in C++ it is permitted to do initializations which are based on runtime data.