Computer Programming
C Programming
C++ Programming

What is null pointer assignment?


Top Answer
User Avatar
Wiki User
Answered 2010-12-07 17:58:54

A pointer variable holds the address of a location in memory. But if the pointer hasn't been given a valid address, you can't dereference it.


A pointer that does not point to any data object.


Related Questions

This error appears due to incorrect assignment to pointer and pointer tries to access illegal memory...

Null pointer assignment means assigning a value to 0th location or accessing 0th location which is run time error should be avoided.

You haven't assigned the pointer yet, so it's initialized as NULL, or you're trying to assign NULL to the value of the pointer. You have to check if the value is NULL before you use it, or you'll end up with errors just like this.

It means that you haven't initialized the pointer or the object it points does not exist any more or not accessible.

This error message means that somewhere in your program you have used a pointer-varible containing NULL-value. (Within an actual OS it with stop the program immediately, but in MS-DOS it doesn't.)

Answer#ifndef NULL# define NULL ((void*)0)#endifAnswerDon't use pointers that contain NULL-value. Eg:int *myptr= NULL;...*myptr = 32; /* wrong */

A null pointer is a pointer variable with the value 0. A null macro is a macro that defines the NULL symbol (typically 0L on a 32-bit system).

A void pointer is a pointer that has no type information attached to it.A null pointer is a pointer that points to "nothing". A null pointer can be of any type (void included, of course).

NULL Macro is simply what is defined as 0 in a macro provided by the libraryNull pointer is a pointer which has 0 or NULL value stored and points to nowhwere still it points to 0x00 i.e. the first memory location of the OSNull pointer != Uninitialized pointer because an uninitialised pointer can point anywhere in the memory location ...but a NULL pointer surely points to no where(but still behind the scene we can say that it only points to 0x00). Never we can retrive a Null pointer location using th"&" operator..neither will malloc/calloc return NULL IF THERE IS SPACE IN THE MEMORY. NULL pointer is unique !!

For example, if you write NULl instead of NULL.

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);}

There are times when it is necessary to have a pointer that doesn't point to anything. The macro NULL, defined in , has a value that's guaranteed to be different from any valid pointer. NULL is a literal zero, possibly cast to void* or char*.

Pointer is a variable that stores address of a variable . A NULL Pointer a pointer that doesn't point to anything, it is a literal zero .Some people ,notably C++ programmers, prefer to use 0 rather than NULL.

A pointer variable which is declared but not initialized is called a NULL POINTER.ex: int *p;Please don't use the above. A NULL pointer is a specific value assigned to a pointer, just like any other value. NULL is a language-specific designation, and is guaranteed to be comparable to, unlike uninitialized variables, which can have any value.That is:int *a;int *b = NULL;int *c = (int *) malloc(sizeof(char));( a c) is NEVER true.NULL is a reserved word in most high-level languages, and indicates a specific value for assignment. It is commonly used to indicate that something has not yet been assigned a "real" value, or has had its contents deleted. It is an EXPLICIT value, and not just "undefined".In the context of pointers (which, remember, are really memory location addresses), a NULL pointer is one which has NO value, and thus does NOT point to any memory location. The difference between an uninitialized pointer and a NULL pointer is that most common languages do not specify what value an uninitialized pointer has upon creation (many, such as C, are assigned a random value), while a NULL pointer explicitly has NO value (which is the meaning of NULL).Many modern languages and compilers will assign NULL to a pointer upon initialization, but don't count on it. It is sloppy programming to do so, and can lead to many hard-to-find errors.

Null pointer assignment is a runtime error. It most often occurs when you attempt to assign a value to the NULL address (hence the name of the error) but it can also occur whenever you attempt to assign a value to an address that does not belong to your process. For example: void f (int* p) { *p = 42; // ... } The above function is unsafe because it assumes ptr always refers to a valid address. As a result, the following will cause a null pointer assignment error: f (NULL); // error! Or, more subtly: void g (int* p) { f (p); // p could be valid, but it could also be NULL or even uninitialised! // ... } To avoid null pointer assignments, always initialise your pointers with a valid address. If you have no suitable address to initialise with, initialise with the NULL address: int* ptr = NULL; Every time your code changes the address assigned to a pointer, the onus is upon your code to ensure the validity of that address. If done consistently, any code that assigns through a potentially NULL address can use a simple assertion: void f (int* p) { assert (p != NULL); *p = 42; // ... } In this way you can catch and eliminate null pointer assignments in debug builds (when NDEBUG is not defined) without paying the cost of runtime testing in release builds (when NDEBUG is defined).

If by 'void pointer 0' you mean '(void *)0', then it is equal to NULL.

A null pointer exception in java comes when you are trying to perform any action on an object that isnt initialized/has a value i.e., is a NULL Value Ex: private String s; //declare a string if(s.equals("test")){ //do something.. } You will get a null pointer in the if condition because you are checking a value that is null which is not allowed..

A NULL pointer has the same size as a non NULL pointer. NULL means that the pointer has been set to the NULL value that is usually zero (0) but the NULL value is at the digression of the compiler manufacture (and may have a value other than zero) so a pointer should always be set to the NULL value and not zero. Current compilers (32 and 64 bit, Intel chip) have a pointer size of 4 (8 bit) bytes. It should be noted that the number of bits in any data type is at the compiler manufactures digression but is heavily influenced by the computer hardware. void *p= NULL; printf ("%d\n", sizeof (p)); or printf ("%d\n", sizeof (void *));

its just an programming error, null definition in Programming is to represent the thing referred to by an uninitialised pointer.

#define NULL ((void *)0) /* defined in <stddef.h> */ const char *mynullvar = NULL;

A Null pointer has the value 0. void pointer is a generic pointer introduced by ANSI. Before ANSI, char pointers are used as generic pointer. Generic pointer can hold the address of any data type. Pointers point to a memory address, and data can be stored at that address.

Assigning an initial value to a pointer variable. Example: int *p= NULL;

... are usable. void pointer (generic pointer) : a special type of pointer which point to some data of no specific types. void *p; null pointer : a special type of pointer which point nowhere. it is usually used to check if a pointer is pointing to a null or free the pointer during deallocation of memory in dynamic memory allocation; it is define by using the predefine constant NULL int *p=NULL; wild pointer : uninitialized pointer. it hold a garbage value. i.e it is not pointing to any memory location yet. dangling pointer: pointer pointing to a destroyed variable. it usually happen during dynamic memory allocation when the object is destroyed but not free and the pointer is still pointing to the destroy object.

I'm going to go out on a limp here, and guess you mean "Null Pointer." Well, it's a pointer to nothing. For most systems, it's 0, but rather use NULL instead.

Copyright ยฉ 2020 Multiply Media, LLC. All Rights Reserved. The material on this site can not be reproduced, distributed, transmitted, cached or otherwise used, except with prior written permission of Multiply.