C++指针与引用的适用场景对比：初学者常见疑问解析

Hey there! Totally get where you're coming from—pointers and references in C++ can feel like overlapping tools at first, but once you nail down their core differences, picking the right one becomes way easier. Let's break down their most common, practical use cases and weigh their pros and cons.

Pointers shine when you need flexibility or have to handle optional/changeable targets:

• When you need to represent an "empty" or optional value
  Unlike references (which must bind to a valid object), pointers can be set to nullptr to signal "no value here." For example, a function that searches an array might return nullptr if the target isn't found:

  int* findInArray(int arr[], int size, int target) {
      for (int i = 0; i < size; ++i) {
          if (arr[i] == target) return &arr[i];
      }
      return nullptr; // Signals "not found"
  }
  

• Dynamic memory management
  When you allocate memory with new or malloc, you get a pointer to that memory. References can't directly handle dynamic allocation (you could bind a reference to a dynamically allocated object, but it's risky—easy to forget to free, and you can't reassign the reference to point to new memory). Example:

  int* dynamicBuffer = new int[100]; // Pointer to heap-allocated array
  delete[] dynamicBuffer;
  

• Reassigning to point to different objects
  Pointers can be updated to point to new objects anytime. This is essential for things like traversing linked lists:

  struct Node { int value; Node* next; };
  Node* current = head;
  while (current != nullptr) {
      current = current->next; // Reassign pointer to next node
  }
  

• Returning multiple optional values from a function
  You mentioned returning multiple values—if some of those values might not be valid (like in a division function where dividing by zero makes the result invalid), pointers let you skip assigning a value:

  bool divide(int numerator, int denominator, int* result) {
      if (denominator == 0) return false; // No result to assign
      *result = numerator / denominator;
      return true;
  }
  

References are your go-to for safety, readability, and avoiding unnecessary copies:

• Passing large objects to functions (without copying)
  If you're passing a big object (like a std::string or a custom class) to a function, using a reference avoids making an expensive copy. Add const if you don't need to modify the original:

  void printLargeString(const std::string& str) {
      std::cout << str << std::endl;
  }
  

• Returning objects without copying (and enabling modification)
  Returning a reference lets you alias an existing object, skipping a copy. This is common for class member accessors or container elements:

  class MyClass {
  private:
      int internalValue;
  public:
      int& getValue() { return internalValue; } // Let caller modify the value
  };
  
  MyClass obj;
  obj.getValue() = 42; // Directly modifies internalValue via reference
  

• Operator overloading
  References make operator chaining possible (like a = b = c). Most operators (like = or +=) return a reference to *this to enable this:

  MyClass& MyClass::operator=(const MyClass& other) {
      if (this != &other) {
          internalValue = other.internalValue;
      }
      return *this; // Enables chaining
  }
  

• Cleaner, more readable code
  References act like aliases for the original object, so you don't have to use * (dereference) or -> syntax. For example, modifying elements in a loop is more intuitive with references:

  std::vector<int> nums = {1, 2, 3};
  for (int& num : nums) {
      num *= 2; // Directly modify original elements, no pointers needed
  }
  

• Safety first? Go with references
  References eliminate the risk of null pointer dereferences (since they must bind to a valid object). They're harder to misuse than pointers, which can accidentally point to invalid memory or be nullptr.
• Need flexibility? Reach for pointers
  If you need to handle optional values, dynamic memory, or reassign what you're pointing to, pointers are the only way to go. They're more powerful but require more care.
• Readability and simplicity? References win
  References look and behave like regular variables, making code easier to read and write. Pointers require explicit dereferencing, which adds visual noise but makes it clear you're working with an indirect value.
• Efficiency? They're nearly identical
  Under the hood, most compilers implement references as pointers. The difference is purely syntactic—so efficiency isn't a reason to choose one over the other.

As a general rule: start with references when you can (they're safer and cleaner), and use pointers only when you need their unique flexibility.

内容的提问来源于stack exchange，提问作者Adam