Are the days of passing const std::string & as a parameter over?

by

The reason Herb said what he said is because of cases like this.

Let’s say I have function A which calls function B, which calls function C. And A passes a string through B and into C. A does not know or care about C; all A knows about is B. That is, C is an implementation detail of B.

Let’s say that A is defined as follows:

void A()
{
  B("value");
}

If B and C take the string by const&, then it looks something like this:

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

void C(const std::string &str)
{
  //Do something with `str`. Does not store it.
}

All well and good. You’re just passing pointers around, no copying, no moving, everyone’s happy. C takes a const& because it doesn’t store the string. It simply uses it.

Now, I want to make one simple change: C needs to store the string somewhere.

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

Hello, copy constructor and potential memory allocation (ignore the Short String Optimization (SSO)). C++11’s move semantics are supposed to make it possible to remove needless copy-constructing, right? And A passes a temporary; there’s no reason why C should have to copy the data. It should just abscond with what was given to it.

Except it can’t. Because it takes a const&.

If I change C to take its parameter by value, that just causes B to do the copy into that parameter; I gain nothing.

So if I had just passed str by value through all of the functions, relying on std::move to shuffle the data around, we wouldn’t have this problem. If someone wants to hold on to it, they can. If they don’t, oh well.

Is it more expensive? Yes; moving into a value is more expensive than using references. Is it less expensive than the copy? Not for small strings with SSO. Is it worth doing?

It depends on your use case. How much do you hate memory allocations?

More Related Contents:

  1. Error while passing vector to instance of object in main
  2. Concurrency: Atomic and volatile in C++11 memory model
  3. When can outer braces be omitted in an initializer list?
  4. What exactly is the “immediate context” mentioned in the C++11 Standard for which SFINAE applies?
  5. C++11 thread-safe queue
  6. const& , & and && specifiers for member functions in C++
  7. Specifying one type for all arguments passed to variadic function or variadic template function w/out using array, vector, structs, etc?
  8. Why doesn’t C++ use std::nested_exception to allow throwing from destructor?
  9. Why doesn’t SFINAE (enable_if) work for member functions of a class template?
  10. Which Boost features overlap with C++11?
  11. Now that we have std::array what uses are left for C-style arrays?
  12. Is #pragma once part of the C++11 standard?
  13. Error: variable “cannot be implicitly captured because no default capture mode has been specified”
  14. why is `std::initializer_list` often passed by value?
  15. copy elision: move constructor not called when using ternary expression in return statement?
  16. Difference between std::result_of and decltype
  17. Why can’t I create a vector of lambdas (of the same type) in C++11?
  18. How to enable experimental C++11 concurrency features in MinGW?
  19. Why there is no placement delete expression in C++?
  20. When do extra parentheses have an effect, other than on operator precedence?
  21. std::fstream buffering vs manual buffering (why 10x gain with manual buffering)?
  22. C++11 rvalue reference calling copy constructor too
  23. Need iterator when using ranged-based for loops
  24. C++ terminate called without an active exception
  25. C++11: Replace all non-owning raw pointers with std::shared_ptr()?
  26. templated typedef?
  27. Can we apply content not explicitly cited from the normative references to the C++ standard?
  28. C++ Passing std::string by reference to function in dll
  29. “What happened to my SFINAE” redux: conditional template class members?
  30. Concatenate compile-time strings in a template at compile time?

Leave a Comment