What are the differences between a pointer variable and a reference variable in C++?

In C++, pointers and references both enable indirect access to variables but differ significantly in syntax, usage, and behavior. Here’s a structured breakdown of their differences:

1. Declaration & Initialization

• Pointer:
• Declared with * (e.g., int* ptr;).
• Can be declared without initialization (but risky if uninitialized).
• Can point to nullptr (null pointer).

  int a = 10;
  int* ptr = &a;  // Points to a
  ptr = nullptr;  // Valid

• Reference:
• Declared with & (e.g., int& ref = a;).
• Must be initialized when declared.
• Cannot be null or reassigned to refer to another variable.

  int a = 10;
  int& ref = a;  // Valid
  // int& ref2;  // Error: must initialize

2. Reassignment

• Pointer: Can be reassigned to point to different addresses.

  int a = 10, b = 20;
  int* ptr = &a;  // Points to a
  ptr = &b;       // Now points to b

• Reference: Bound to one variable for its lifetime.

  int a = 10, b = 20;
  int& ref = a;
  // ref = b;    // Assigns b's value to a (a = 20), ref still refers to a

3. Memory Address & Dereferencing

• Pointer:
• Stores the memory address of a variable.
• Requires explicit dereferencing (*) to access/modify the value.

  int a = 10;
  int* ptr = &a;  // ptr holds a's address
  *ptr = 20;      // a = 20

• Reference:
• Acts as an alias for the variable (no separate memory address).
• Accessed like a normal variable (no explicit dereferencing).

  int a = 10;
  int& ref = a;  // ref is an alias for a
  ref = 20;      // a = 20

4. Nullability

• Pointer: Can be nullptr (useful for optional parameters or error handling).

  int* ptr = nullptr;  // Valid

• Reference: Must always refer to a valid object (no null references).

  // int& ref = nullptr;  // Error: invalid

5. Memory Operations

• Pointer:
• Supports pointer arithmetic (e.g., ptr++ to navigate arrays).
• Can have multiple levels of indirection (e.g., int** for pointers to pointers).

  int arr[3] = {1, 2, 3};
  int* ptr = arr;
  ptr++;  // Points to arr[1]

• Reference:
• No pointer arithmetic (treated like the variable itself).
• No “reference to a reference” (single level only).

6. Use Cases

• Pointer:
• Dynamic memory allocation (new/delete).
• Optional function parameters (using nullptr).
• Low-level memory manipulation (e.g., arrays, hardware access).
• Reference:
• Function parameters to avoid copying (e.g., void func(int& x)).
• Operator overloading for cleaner syntax (e.g., std::ostream& operator<<).
• Range-based for loops (e.g., for (auto& x : vec)).

7. Safety

• Pointer:
• Risk of dangling pointers (pointing to deallocated memory).
• Requires manual memory management (potential for leaks).
• Reference:
• Safer (cannot be null or dangling if the referred object is in scope).
• Managed by the compiler (no explicit memory handling).

8. Function Parameters

• Pointer:

  void modify(int* ptr) {
    if (ptr) *ptr = 20;  // Check for nullptr
  }
  modify(&a);  // Explicitly pass address

• Reference:

  void modify(int& ref) {
    ref = 20;  // Directly modify the original variable
  }
  modify(a);   // Pass variable directly

Summary Table

Feature	Pointer (int* ptr)	Reference (int& ref)
Declaration	*	& (must initialize)
Reassignment	Allowed	Not allowed
Nullability	Can be nullptr	Cannot be null
Dereferencing	Explicit (*ptr)	Implicit (ref)
Memory Operations	Arithmetic and indirection	None
Use Cases	Dynamic memory, optional	Function args, aliases
Safety	Riskier	Safer (no null/dangling)

Key Takeaways

• Use pointers for dynamic memory, optional parameters, or low-level control.
• Use references for safer aliases, function parameters, or operator overloading.
• Prefer references when possible to avoid bugs like null dereferencing.