What is the difference between a pointer and a reference in C++?

In C++, both pointers and references are used to indirectly access objects or variables. However, there are some key differences between them. Let’s explore these differences with examples:

1. Definition and Initialization:
   • Pointers: Pointers are variables that store memory addresses. They can be declared using the asterisk (*) symbol. Pointers can be assigned null or uninitialized values.

int* ptr;         // Declaration of a pointer
int* ptr = nullptr;   // Initialization with null value
int* ptr = #      // Initialization with address of 'num' variable

• References: References are aliases or alternative names for existing objects. They must be initialized upon declaration and cannot be null or uninitialized.

int num = 42;
int& ref = num;   // Declaration and initialization of a reference

2. Syntax and Usage:

• Pointers: To access the value pointed to by a pointer, we use the dereference operator (*). Pointers can be reassigned to point to different memory locations.

int* ptr = #     // 'ptr' points to 'num'
*ptr = 10;           // Modifying the value of 'num' indirectly through 'ptr'
int* anotherPtr = ptr;   // 'anotherPtr' now points to the same memory location as 'ptr'

• References: References are automatically dereferenced, so there is no need for the dereference operator (*). Once a reference is initialized, it cannot be made to refer to a different object.

int num = 42;
int& ref = num;       // 'ref' is an alias for 'num'
ref = 10;             // Modifying 'num' directly through 'ref'
int& anotherRef = ref;   // 'anotherRef' is another alias for 'num'

3. Nullability:

• Pointers: Pointers can have a null value, which means they do not point to any valid memory address. This can be useful to indicate the absence of a valid object.

int* ptr = nullptr;   // Null pointer
if (ptr != nullptr) {
    // Access the value only if the pointer is not null
    int value = *ptr;
}

• References: References cannot be null. They must always be initialized and refer to a valid object.

int num = 42;
int& ref = num;   // Reference cannot be null

4. Reassignment:

• Pointers: Pointers can be reassigned to point to a different memory address.

int num1 = 42;
int num2 = 10;
int* ptr = &num1;    // 'ptr' points to 'num1'
ptr = &num2;         // 'ptr' now points to 'num2'

• References: References cannot be reassigned to refer to a different object after initialization.

int num1 = 42;
int num2 = 10;
int& ref = num1;     // 'ref' refers to 'num1'
ref = num2;          // Value of 'num1' changes, but 'ref' still refers to 'num1'

It’s worth noting that pointers provide more flexibility and can be used to achieve complex operations, such as dynamic memory allocation, while references are generally simpler to use and offer more intuitive syntax. The choice between pointers and references