Should You Pass `std::string` and `std::vector` by Value or Const Reference?

Passing Parameters by Value: Rethinking const std::string &

Herb Sutter recently questioned the conventional practice of passing std::vector and std::string objects by const reference. He suggests that in many cases, passing them by value is now preferable, as demonstrated in the following code:

std::string do_something(std::string inval) {
  std::string return_val;
  // ... do stuff ...
  return return_val;
}

While the return value is an rvalue at the point of function return and can be moved cost-effectively, the rationale for Sutter's statement lies in cases like this:

Consider a function A that invokes function B, which in turn invokes function C. A passes a string parameter to B, which forwards it to C. A has no direct knowledge of C.

If B and C take the string by const reference, the code would appear as follows:

void B(const std::string &str) {
  C(str);
}

void C(const std::string &str) {
  // Process `str` without storing it.
}

With this approach, passing and receiving pointers suffices, avoiding costly copying or moving.

However, if C needs to store the string:

void C(const std::string &str) {
  // Process `str`.
  m_str = str;
}

This triggers a copy constructor and potential memory allocation (ignoring Short String Optimization). While C 11's move semantics aim to eliminate unnecessary copying, C taking a const reference prevents this, despite A passing a temporary string.

Conversely, if str were passed by value through all functions, relying on move semantics to transfer ownership, C could either adopt or discard the data without causing a copy operation. This approach comes with a slight performance overhead, but it eliminates memory allocations, which may be advantageous depending on the specific use case.

The above is the detailed content of Should You Pass `std::string` and `std::vector` by Value or Const Reference?. For more information, please follow other related articles on the PHP Chinese website!