Null Pointer

#include <iostream>
using namespace std;

int main() {
    int* ptr = nullptr;  // C++11 way (preferred)
    // int* ptr = NULL;  // C way
    // int* ptr = 0;     // Alternative
    
    cout << "Pointer value: " << ptr << endl;
    
    // Check if pointer is null
    if (ptr == nullptr) {
        cout << "Pointer is null (not pointing to anything)" << endl;
    }
    
    // Safe to check before dereferencing
    if (ptr != nullptr) {
        cout << "Value: " << *ptr << endl;
    } else {
        cout << "Cannot dereference null pointer!" << endl;
    }
    
    // Allocate memory
    ptr = new int(42);
    
    if (ptr != nullptr) {
        cout << "\nAfter allocation:" << endl;
        cout << "Pointer value: " << ptr << endl;
        cout << "Value pointed: " << *ptr << endl;
    }
    
    // Deallocate and set to null
    delete ptr;
    ptr = nullptr;  // Good practice: set to null after delete
    
    if (ptr == nullptr) {
        cout << "\nPointer set to null after deletion" << endl;
    }
    
    return 0;
}

Pointer value: 0
Pointer is null (not pointing to anything)
Cannot dereference null pointer!

After allocation:
Pointer value: 0x7f8a5b402670
Value pointed: 42

Pointer set to null after deletion

This program teaches you how to use Null Pointers in C++. A null pointer doesn't point to any valid memory location. It's essential for safe pointer handling, preventing crashes, and indicating that a pointer doesn't currently point to anything.

---

1. What This Program Does

The program demonstrates null pointer usage:

• Initializing pointers to nullptr
• Checking if pointer is null before dereferencing
• Setting pointer to null after deletion
• Safe pointer handling practices

Null pointers prevent undefined behavior and crashes.

---

2. Header File Used

#include <iostream>

This header provides:

• cout for displaying output
• cin for taking input from the user

---

3. Understanding Null Pointers

Null Pointer Concept:

• Pointer that doesn't point to any valid memory
• Indicates "no object" or "not initialized"
• Safe to check but not to dereference
• Essential for safe pointer handling

C++11 Way:

int* ptr = nullptr; // Preferred

Legacy Ways:

int* ptr = NULL; // C way (macro) int* ptr = 0; // Alternative (not recommended)

---

4. Initializing to Null

Safe Initialization:

int* ptr = nullptr; // Initialize to null

Why?

• Prevents uninitialized pointer
• Can safely check if (ptr == nullptr)
• Prevents accidental dereferencing
• Good programming practice

---

5. Checking for Null

Before Dereferencing:

if (ptr != nullptr) { cout << *ptr << endl; // Safe to dereference } else { cout << "Pointer is null!" << endl; }

How it works:

• Always check before dereferencing
• Prevents crashes from null pointer dereference
• Essential safety check

---

6. Setting to Null After Deletion

Good Practice:

delete ptr; ptr = nullptr; // Set to null after deletion

Why?

• Prevents dangling pointer
• Can check if pointer was deleted
• Prevents double deletion
• Makes code safer

---

7. When to Use Null Pointers

Best For:

• Pointer initialization
• Error handling (function returns null on error)
• End-of-list markers (linked lists)
• Optional parameters
• Conditional object creation

Example Scenarios:

• Function returns null if allocation fails
• Linked list: null indicates end
• Optional function parameters
• Conditional object pointers

---

8. Null Pointer Dereference

Danger:

int* ptr = nullptr; *ptr = 10; // CRASH! Undefined behavior

Why Crashes?

• Tries to access invalid memory
• Operating system prevents access
• Program crashes or undefined behavior
• Always check before dereferencing

---

9. Important Considerations

nullptr vs NULL vs 0:

• nullptr: C++11, type-safe, preferred
• NULL: C macro, less type-safe
• 0: Works but not recommended

Type Safety:

• nullptr is type-safe
• Cannot be confused with integer 0
• Better compiler error messages

Best Practices:

• Always initialize pointers
• Check for null before dereferencing
• Set to null after deletion
• Use nullptr (not NULL or 0)

---

10. return 0;

This ends the program successfully.

---

Summary

• Null pointer: doesn't point to any valid memory location.
• Use nullptr (C++11) - preferred over NULL or 0.
• Always check if pointer is null before dereferencing.
• Set pointer to null after deletion to prevent dangling pointers.
• Essential for safe pointer handling and preventing crashes.
• Understanding null pointers prevents undefined behavior.
• Useful for initialization, error handling, and optional parameters.

This program is fundamental for learning safe pointer practices, understanding error handling, and preparing for robust memory management in C++ programs.