||This article should be divided into sections by topic, to make it more accessible. (March 2015)|
In computing, a null pointer has a value reserved for indicating that the pointer does not refer to a valid object. Programs routinely use null pointers to represent conditions such as the end of a list of unknown length or the failure to perform some action; this use of null pointers can be compared to nullable types and to the Nothing value in an option type.
A null pointer should not be confused with an uninitialized pointer: A null pointer is guaranteed to compare unequal to any pointer that points to a valid object. However, depending on the language and implementation, an uninitialized pointer may not have any such guarantee. It might compare equal to other, valid pointers; or it might compare equal to null pointers. It might do both at different times.
Null pointers are often considered[by whom?] similar to null values in relational databases, but they have somewhat different semantics. A null pointer in most programming languages means "no value", while a null value in a relational database means "unknown value". This leads to important differences in practice: most programming languages will treat two null pointers as equal, but a relational database engine does not regard two null values as equal (since they represent unknown values, it is unknown whether they are equal).
In C, two null pointers of any type are guaranteed to compare equal. The macro
NULL is defined as an implementation-defined null pointer constant, which in C99 can be portably expressed as the integer value
0 converted implicitly or explicitly to the type
Dereferencing the NULL pointer typically results in an attempted read or write from memory that is not mapped - triggering a segmentation fault or access violation. This may represent itself to the developer as a program crash, or be transformed into an exception that can be caught. There are, however, certainly circumstances where this is not the case. For example, in x86-real mode, the address 0000:0000 is readable and usually writable, hence dereferencing the null pointer is a perfectly valid but typically unwanted action that may lead to undefined but non-crashing behaviour in the application. Note also that there are occasions when dereferencing the NULL is intentional and well defined; for example BIOS code written in C for 16-bit real-mode x86 devices may write the IDT at physical address 0 of the machine by dereferencing a NULL pointer for writing. It is also possible for the compiler to optimize away the `NULL` pointer dereference, avoiding a segmentation fault but causing other undesired behavior.
In C++, while the
NULL macro was inherited from C, the integer literal for zero has been traditionally preferred to represent a null pointer constant. However, C++11 has introduced an explicit
nullptr constant to be used instead.
In some programming language environments (at least one proprietary Lisp implementation, for example), the value used as the null pointer (called
nil in Lisp) may actually be a pointer to a block of internal data useful to the implementation (but not explicitly reachable from user programs), thus allowing the same register to be used as a useful constant and a quick way of accessing implementation internals. This is known as the
In languages with a tagged architecture, a possibly null pointer can be replaced with a tagged union which enforces explicit handling of the exceptional case; in fact, a possibly null pointer can be seen as a tagged pointer with a computed tag.
Because a null pointer does not point to a meaningful object, an attempt to dereference a null pointer usually (but not always) causes a run-time error or immediate program crash.
- In C, the behavior of dereferencing a null pointer is undefined. Many implementations cause such code to result in the program being halted with a segmentation fault, because the null pointer representation is chosen to be an address that is never allocated by the system for storing objects. However, this behavior is not universal.
- In Java, access to a null reference triggers a
NullPointerException(NPE), which can be caught by error handling code, but the preferred practice is to ensure that such exceptions never occur.
- In .NET, access to null reference triggers a NullReferenceException to be thrown. Although catching these is generally considered bad practice, this exception type can be caught and handled by the program.
- In Objective-C, messages may be sent to a
nilobject (which is a null pointer) without causing the program to be interrupted; the message is simply ignored, and the return value (if any) is
0, depending on the type.
In 2009 C.A.R. Hoare stated that he invented the null reference in 1965 as part of the Algol W language, although NIL had existed in Lisp since 1959. In that 2009 reference Hoare describes his invention as a "billion-dollar mistake":
I call it my billion-dollar mistake. It was the invention of the null reference in 1965. At that time, I was designing the first comprehensive type system for references in an object oriented language (ALGOL W). My goal was to ensure that all use of references should be absolutely safe, with checking performed automatically by the compiler. But I couldn't resist the temptation to put in a null reference, simply because it was so easy to implement. This has led to innumerable errors, vulnerabilities, and system crashes, which have probably caused a billion dollars of pain and damage in the last forty years.
- ISO/IEC 9899, clause 18.104.22.168, paragraph 4.
- ISO/IEC 9899, clause 7.17, paragraph 3: NULL... which expands to an implementation-defined null pointer constant...
- ISO/IEC 9899, clause 22.214.171.124, paragraph 3.
- Stroustrup, Bjarne (March 2001). "Chapter 5: Pointers, Arrays, and Structures: 5.1.1: Zero". The C++ Programming Language (14th printing of 3rd ed.). United States and Canada: Addison–Wesley. p. 88. ISBN 0-201-88954-4.
In C, it has been popular to define a macro
NULLto represent the zero pointer. Because of C++'s tighter type checking, the use of plain 0, rather than any suggested
NULLmacro, leads to fewer problems. If you feel you must define
const int NULL = 0;
constqualifier (§5.4) prevents accidental redefinition of
NULLand ensures that
NULLcan be used where a constant is required.
- ISO/IEC 9899, clause 126.96.36.199, paragraph 4.
- The Objective-C 2.0 Programming Language, section "Sending Messages to nil".
- Tony Hoare (2009). "Null References: The Billion Dollar Mistake". QCon London.
- Tony Hoare (2009-08-25). "Null References: The Billion Dollar Mistake". InfoQ.com.
- Joint Technical Committee ISO/IEC JTC 1, Subcommittee SC 22, Working Group WG 14 (2007-09-08). International Standard ISO/IEC 9899 (COMMITTEE DRAFT)..