Null Pointer - Revision history

Proj user18: /* C++ */

2016-12-18T21:35:27Z

‎C++

Proj user18: /* Check for a Null pointer */

2016-12-18T21:31:21Z

‎Check for a Null pointer

Proj user18 at 21:30, 18 December 2016

2016-12-18T21:30:06Z

Proj user18 at 21:26, 18 December 2016

2016-12-18T21:26:16Z

Proj user18: /* Check for a Null pointer */

2016-12-18T21:19:25Z

‎Check for a Null pointer

Proj user18 at 21:17, 18 December 2016

2016-12-18T21:17:19Z

Proj user18: /* Example of Null pointer */

2016-12-18T21:10:04Z

‎Example of Null pointer

Proj user18: /* Example of Null pointer */

2016-12-18T21:05:07Z

‎Example of Null pointer

Proj user18: /* Example of Null pointer */

2016-12-18T21:00:36Z

‎Example of Null pointer

Proj user18: /* NULL */

2016-12-18T20:56:19Z

‎NULL

@@ Line 65: / Line 65: @@
 </syntaxhighlight>
 <BR/>
+Nullptr is a null pointer constant of type std::nullptr_t. Although the keyword nullptr can be used without including any headers, if the code uses the type std::nullptr_t, then you must define it by including the header <cstddef>.
 == Check for a Null pointer ==

@@ Line 85: / Line 85: @@
          printf("ptr is a null pointer.\n");
+    }
-    if(f_ptr)
+   if(f_ptr)
+    {
         printf("f_ptr is not a null pointer.\n");

← Older revision		Revision as of 21:30, 18 December 2016
Line 1:		Line 1:
−	~~NULL~~ Pointer is a pointer which points to nothing. A null pointer in most programming languages means "no value". Null pointers represent conditions such as the end of a list of unknown length or the failure to perform some operation.	+	A Null Pointer is a pointer which points to nothing. A null pointer in most programming languages means "no value". Null pointers represent conditions such as the end of a list of unknown length or the failure to perform some operation.

	A null pointer is different from an uninitialized pointer: A null pointer will always compare unequal to any pointer that points to a valid object, while an uninitialized pointer might point anywhere. Uninitialized pointer may be equal to other, valid pointers; or it might compare equal to null pointers.		A null pointer is different from an uninitialized pointer: A null pointer will always compare unequal to any pointer that points to a valid object, while an uninitialized pointer might point anywhere. Uninitialized pointer may be equal to other, valid pointers; or it might compare equal to null pointers.

@@ Line 1: / Line 1: @@
-NULL Pointer is a pointer which is pointing to nothing. A null pointer in most programming languages means "no value". Null pointers represent conditions such as the end of a list of unknown length or the failure to perform some operation.
+NULL Pointer is a pointer which points to nothing. A null pointer in most programming languages means "no value". Null pointers represent conditions such as the end of a list of unknown length or the failure to perform some operation.
 A null pointer is different from an uninitialized pointer: A null pointer will always compare unequal to any pointer that points to a valid object, while an uninitialized pointer might point anywhere. Uninitialized pointer may be equal to other, valid pointers; or it might compare equal to null pointers.
@@ Line 6: / Line 6: @@
 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 expressed as the integer value 0 converted implicitly or explicitly to the type void*.
-Dereferencing the NULL pointer typically results in an attempted read or write from memory that is not mapped - triggering a segmentation fault. This shows up as program crash or be transformed into an exception that can be caught. There are, however, certain 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.
+Dereferencing the NULL pointer typically results in an attempted read or write from memory that is not mapped - triggering a segmentation fault. This shows up as program crash or be transformed into an exception that can be caught.
 ==== NULL ====
-As a matter of style, many programmers prefer not to have  0's scattered through their programs to represent pointers. Therefore, the preprocessor macro NULL is defined (by headers such as <stdio.h> and <stddef.h>) as a null pointer constant, typically 0 or ((void *)0). A programmer who wishes to make explicit the distinction between 0 the integer and 0 the null pointer constant can then use NULL whenever a null pointer is required.
+As a good practice, many programmers prefer not to have  0's scattered through their programs to represent pointers. Therefore, the preprocessor macro NULL is defined (by headers such as <stdio.h> and <stddef.h>) as a null pointer constant, typically 0. A programmer who wishes to make explicit the distinction between 0 the integer and 0 the null pointer constant can then use NULL whenever a null pointer is required.
 <syntaxhighlight lang="C">
@@ Line 16: / Line 18: @@
 <BR/>
-Using NULL is a stylistic convention only; the preprocessor turns NULL back into 0 which is then recognized by the compiler, in pointer contexts, as before. In particular, a cast may still be necessary before NULL (as before 0) in a function call argument. The table under question 5.2 above applies for NULL as well as 0 (an unadorned NULL is equivalent to an unadorned 0).
+Using NULL is a stylistic convention only; the preprocessor turns NULL back into 0 which is then recognized by the compiler, in pointer contexts, as before. In particular, a cast may still be necessary before NULL (as before 0) in a function call argument.
 NULL is macro constant defined in following header files –
 #stdio.h

← Older revision		Revision as of 21:19, 18 December 2016
Line 105:		Line 105:
	</syntaxhighlight>		</syntaxhighlight>
	<BR/>		<BR/>
		+
		+	If all unused pointers are assigned a null value, accidental misuse of an uninitialized pointer can be avoided. Many times, uninitialized variables hold some junk values and it becomes difficult to debug the program.

@@ Line 61: / Line 61: @@
 int* x = nullptr;
 myclass* obj = nullptr;
 </syntaxhighlight>
 <BR/>

@@ Line 31: / Line 31: @@
 int main()
+{
-    int  *ptr = NULL;          //Best way to a
+    int  *ptr = NULL;           //Best way to assign the pointer Null to a pointer variable. Works for any data type.
-    float *f_ptr = (float *)0;
+    float *f_ptr = (float *)0;  //Another way to assign the pointer Null to a pointer variable of type float.
-    char *c_ptr = '\0';
+    char *c_ptr = '\0';         //Assigning the pointer Null to a pointer variable of type char.
-    double *d_ptr = (double *)0;
+    double *d_ptr = (double *)0;//Another way to assign the pointer Null to a pointer variable of type double.
     printf("The value of ptr is %u\n",ptr);

@@ Line 32: / Line 32: @@
+{
     int  *ptr = NULL;
-    printf("The value of ptr is %u",ptr);
+    float *f_ptr = (float *)0;
     return 0;
+}
@@ Line 42: / Line 48: @@
 <syntaxhighlight lang="C">
 The value of ptr is 0
 </syntaxhighlight>
 <BR/>
 == C++==
 In 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.

@@ Line 10: / Line 10: @@
 ==== NULL ====
 As a matter of style, many programmers prefer not to have  0's scattered through their programs to represent pointers. Therefore, the preprocessor macro NULL is defined (by headers such as <stdio.h> and <stddef.h>) as a null pointer constant, typically 0 or ((void *)0). A programmer who wishes to make explicit the distinction between 0 the integer and 0 the null pointer constant can then use NULL whenever a null pointer is required.
 Using NULL is a stylistic convention only; the preprocessor turns NULL back into 0 which is then recognized by the compiler, in pointer contexts, as before. In particular, a cast may still be necessary before NULL (as before 0) in a function call argument. The table under question 5.2 above applies for NULL as well as 0 (an unadorned NULL is equivalent to an unadorned 0).
@@ Line 20: / Line 25: @@
 NULL should be used only as a pointer constant. It is bad practice to use NULL to assign 0 value to a variable.
 == Example of Null pointer ==