Null көрсеткіш немесе сілтеме туралы мәліметтер

Value indicating that a referenced dataset is invalid or doesn't exist

In computing, a null pointer or null reference is a value saved for indicating that the pointer or reference 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, in general, most languages do not offer 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; or the comparison might be undefined behaviour. Also, in languages offering such support, the correct use depends on the individual experience of each developer an linter tools. Even when used properly, null pointers are semantically incomplete, since they do not offer the possibility to express the difference between of a "Not Applicable" value versus a "Not known" value or versus a "Future" value. Because a null pointer does not point to a meaningful object, an attempt to access the data stored at that (invalid) memory location may cause a run time error or immediate program crash. This is the null pointer error. It is one of the most common types of software weaknesses, and Tony Hoare, who introduced the concept, has referred to it as a "billion dollar mistake".

In C, two null pointers of any type are guaranteed to compare equal. The preprocessor macro NULL is defined as an implementation defined null pointer constant in <stdlib. h>, which in C99 can be portably expressed as ((void *)0), the integer value 0 converted to the type void* (see pointer to void type). The C standard does not say that the null pointer is the same as the pointer to memory address 0, though that may be the case in practice. Dereferencing a null pointer is undefined behavior in C,

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 introduced the explicit null pointer constant nullptr and type nullptr t 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 nil vector. 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. Programming languages use different literals for the null pointer. In Python, for example, a null value is called None. In Pascal and Swift, a null pointer is called nil. In Eiffel, it is called a void reference.

Because a null pointer does not point to a meaningful object, an attempt to dereference (i. e., access the data stored at that memory location) a null pointer usually (but not always) causes a run time error or immediate program crash. MITRE lists the null pointer error as one of the most commonly exploited software weaknesses. In C, dereferencing a null pointer is undefined behavior. Many implementations cause such code to result in the program being halted with an access violation, 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. It is also not guaranteed, since compilers are permitted to optimize programs under the assumption that they are free of undefined behavior. In Delphi and many other Pascal implementations, the constant represents a null pointer to the first address in memory which is also used to initialize managed variables. Dereferencing it raises an external OS exception which is mapped onto a Pascal exception instance if the unit is linked in the clause. In Java, access to a null reference causes a (NPE), which can be caught by error handling code, but the preferred practice is to ensure that such exceptions never occur. In Lisp, is a first class object. By convention, (first nil) is , as is (rest nil). So dereferencing in these contexts will not cause an error, but poorly written code can get into an infinite loop. In NET, access to null reference causes a 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 object (which is a null pointer) without causing the program to be interrupted; the message is simply ignored, and the return value (if any) is or , depending on the type. Before the introduction of Supervisor Mode Access Prevention (SMAP), a null pointer dereference bug could be exploited by mapping page zero into the attacker's address space and hence causing the null pointer to point to that region. This could lead to code execution in some cases.

There are techniques to facilitate debugging null pointer dereferences. Bond et al. D, and Rust. Similar analysis can be performed using external tools, in some languages.

As a rule of thumb, for each type of struct or class, define some objects representing some state of the business logic replacing the undefined behaviour on null. For example, "future" to indicate a field inside an structure that will not be available right now (but for which we known in advance that in a future it will defined), "not applicable" to indicate a field in a non normalized structure, "error", "timeout" to indicate that the field could not be initialized (probably stopping normal execution of the full program, thread, request or command).