CODEWITHSUNDEEP
cpointers
yaylitzis
yaylitzis

Reputation: 5544

a new declared pointer, where it points?

I am learning now C, and these days I am studying pointers and I just come with a question!

int *ptr;       //declare the ptr
ptr = &var;     //init the ptr with the address of the variable var

with these lines, I created a pointer and I linked the ptr with a variable. My question is this, when I declare a pointer int *ptr; and I don't initialize it with an address, this pointer where it points?

Upvotes: 1

Views: 116

Answers (6)

ThunderGr
ThunderGr

Reputation: 2367

Actually, as it has been stated in almost all answers so far, the pointer's value is unknown and consists of the contents of the memory at that location when it was allocated.

Contrary to what some answers state though, noone and nothing is going to forbid you dereferencing it, or doing any kind of operation with this pointer.

As a result, using such a pointer will produce any kind of unpredictable results. It is not only best practice but a requirement for producing less buggy code, to initialize a pointer on declaration to something, even if that something is, simply, NULL.

Upvotes: 1

Kerrek SB
Kerrek SB

Reputation: 477368

In C, variables are generally not initialized unless you specifically say so:

int a;                 // not initialized
int b = 1;             // initialized

int arr[10];           // not initialized
int brr[4] =  { 1 };   // initialized as { 1, 0, 0, 0 }

void * p;              // not initialized
void * q = &a;         // initialized

(There are exceptions for variables with static or thread-local storage, which are always zero-initialized.)

It is not allowed to try and get at the value of an uninitialized variable. The only thing you can do with an uninitialized variable is assign to it, which does not access its current value, but only assigns a new value to it. Before initialization or assignment, the current value of a variable is "indeterminate" and you must not attempt to access it. Doing so results in undefined behaviour.

This is true for all variables, but in particular it applies to your pointer variable. It simply has no meaningful value until you assign one.

void * p;              // not initialized

if (p) { /*...*/ }     // undefined behaviour!
printf("%p\n", p);     // undefined behaviour!

p = &a;                // now p has a well-defined value

The technical term for the action that is causing undefined behaviour is the so-called "lvalue conversion". That is the moment in which you take a named variable (an "lvalue") and use its content. E.g. C11, 6.3.2.1/2 says:

If the lvalue designates an object of automatic storage duration [...] and that object is uninitialized (not declared with an initializer and no assignment to it has been performed prior to use), the behavior is undefined.

Upvotes: 2

Jeremiah Willcock
Jeremiah Willcock

Reputation: 30989

It is just like any other uninitialized local variable -- it is undefined where it points or what value it contains, and you are not allowed to use it (e.g., dereference it) until it is initialized. As stated in @WhozCraig's comment, almost all other operations are forbidden as well (using the pointer's value at all, including arithmetic and comparisons). Uninitialized non-pointer variables (even those with simple types such as ints) cannot be used for any operations that access their values, either.

Upvotes: 2

kviiri
kviiri

Reputation: 3302

Like any other non-static variable in C, it's not initialized automatically. It contains whatever junk data was in the memory slot, and so deferencing it before assigning a proper value to it is likely to be a bad idea.

Upvotes: 0

PMF
PMF

Reputation: 17268

In this case, it will point anywhere. You don't know. The contents of the pointer will be whatever was at the memory location before. So this is very dangerous and should be avoided. You should always init a pointer with NULL, then it will point to "nothing" in a defined way.

Upvotes: 0

Igor Popov
Igor Popov

Reputation: 2620

It points to a random memory location. Dereferencing such a pointer usually leads to a segfault.

Upvotes: 0

Related Questions