What are the differences between C++ pointers and references - 面试题

Differences Between C++ Pointers and References

Pointers and references are two important concepts in C++. They have many similarities in syntax and usage, but there are significant differences in their underlying implementation and characteristics.

Main Differences

1. Memory Usage

Pointers: Occupy 4 bytes (32-bit systems) or 8 bytes (64-bit systems) of memory space
References: Do not occupy additional memory space, they are just aliases for variables

2. Initialization Requirements

Pointers: Can be uninitialized, can be declared without pointing to any valid address
References: Must be initialized when declared, and once bound cannot be changed

3. Null Value Handling

Pointers: Can be set to nullptr or NULL, indicating no object is pointed to
References: Cannot be null, must always reference a valid object

4. Reassignment

Pointers: Can be reassigned to point to different objects
References: Once initialized, cannot change the referenced object

5. Operators

Pointers: Use * and -> operators to access the pointed object
References: Access directly using variable names, no additional operators needed

6. Multi-level References

Pointers: Support multi-level pointers (e.g., int**)
References: Do not support multi-level references

Use Cases

Pointers are suitable for:

Dynamic memory allocation
Needing to reassign to point to different objects
Needing to represent a "no object" state
Implementing data structures (linked lists, trees, etc.)

References are suitable for:

Function parameter passing to avoid copy overhead
Function return values to support chaining
Operator overloading
Ensuring parameters are not null

Code Examples

cpp
// Pointer example
int* ptr = nullptr;
int a = 10;
ptr = &a;
*ptr = 20;  // a becomes 20

// Reference example
int b = 10;
int& ref = b;
ref = 30;  // b becomes 30

// Function parameter example
void swap(int* x, int* y) {
    int temp = *x;
    *x = *y;
    *y = temp;
}

void swap(int& x, int& y) {
    int temp = x;
    x = y;
    y = temp;
}

Notes

In modern C++, prefer using references and smart pointers, avoid using raw pointers
References used as function parameters can provide better code readability
Pointers require manual memory management, which can lead to memory leaks. Consider using smart pointers (std::unique_ptr, std::shared_ptr)