What is the difference between uninitialized pointer and null pointer in c language?

Answer 1

An uninitialized pointer is a pointer that has not been assigned a value; it's uninitialized.

The value of an uninitialized pointer is undefined (it could be anything).

A null pointer is simply a pointer that has a value of NULL.

A word of advice: initialize your pointers to NULL.

This allows you to see that the pointer is invalid; to check if an uninitialized pointer is valid is quite impossible.

Examples:

Uninitialized:

int *myPointer;

Null-pointer:

int *myNullPointer = NULL;

Dereferencing either of these pointers is something you'll like to avoid.

It is very common in a program to check for null pointers; some functions return NULL on failure, for example:

struct Foo *result = doSomething();

if (result == NULL) {

printf("Error: The function doSomething() returned NULL);

return;

} else {

printf("The result: %d", result->bar);

}

Answer 2

A null pointer is a pointer that has been initialised with the NULL value (zero). An uninitialised pointer is one that has not be initialised to any value and will in fact store whatever value happened to reside in the pointer's own memory address at the point of instantiation. Uninitialised pointers are a clear sign of bad programming because the only safe way to determine if a pointer is valid or not is to compare its value with NULL. An uninitialised pointer will almost always be non-NULL, which means you run the risk of accessing memory that either does not belong to you, or is otherwise invalid. Most compilers include a debug switch to warn you when you attempt to access any uninitialised variable, which naturally includes pointer variables. This switch must be on at all times.

Whenever you instantiate a pointer, always initialise it straight away, either by nullifying it, or by storing a valid memory address in it. When you are finished with the pointer, it's good practice to nullify it immediately, even if the pointer would subsequently fall from scope. If the pointer is to be immediately re-assigned, there is no need to nullify it (but it's good practice nonetheless). If you follow this practice at all times, you can be assured that any non-NULL pointer will always be pointing at something valid (and if it isn't, then you have some serious problems elsewhere in your code).

As a rule of thumb, if you can use a reference rather than a pointer, use a reference. They are much easier to work with. Pointers should only be used if there's any possibility (however remote) that a reference could be NULL, because a NULL reference will completely invalidate your program (pointers can be NULL, but references can never be NULL). This is why functions such as malloc() and calloc(), and the C++ new operator all return pointers rather than references. You can only return a reference when an allocation is guaranteed to succeed, and a dynamic memory allocation simply cannot make that guarantee.

Answer 3

A NULL pointer is a pointer variable that stores the value zero. Although there is a memory address at offset 0, this value is reserved to indicate that the pointer is not pointing at any valid memory.

A void pointer is a pointer variable that has no specific type. For instance, int * p; tells the compiler that p will point to a memory location that will be treated as if it were an int type (even if it is a char, or some other type), whereas void * p; tells the compiler that the memory being pointed at has no specific type, and that the type will be determined at runtime by casting the pointer to the appropriate type. This allows the pointer to point to anything, including NULL. An int pointer can also point at anything, but its type is known at runtime and will be treated as such at runtime. The type of a void pointer can only be determined at runtime.

Answer 4

Unitialized pointer may contain any value, so if you should use them, the results are unpredictable; NULL value on the other hands explicitly means that the pointer does not point anywhere.

e.g.:

size_t ListLen (const List *p)

{

size_t len= 0;

while (p != NULL) {

++len;

p= p->Next;

}

return len;

}

Answer 5

An uninitialized pointer is the same as any other uninitialized variable. It has no definite value. Using (or dereferencing) an uninitialized pointer can result in bad results or damage to some unknown area of the program, data, or operating system, or it can result in a bus fault.

Answer 6

An uninitialised pointer is a pointer that has been instantiated but has not yet been assigned a valid memory address. If you attempt to dereference whatever address happens to exist in the pointer when it was instantiated, then undefined behaviour will result. This is no different to using any other type of variable that has not yet been initialised.

A null pointer is a pointer that has been assigned address zero, which simply means "does not point at any address".

int *p; // uninitialised pointer -- do not dereference until initialised!!

p = 0; // ok -- points at nothing

p = malloc (sizeof(int)); // ok -- holds a valid address or zero if the allocation failed

Note: if the result of a malloc is address 0, it means the allocation failed, but the pointer is in a valid state. You should always check a pointer is non-null before attempting to dereference the pointer.