Pass By Copy Implications

Question

Ok, I'm thinking about the following C++ code:

foo (std::string str) {
  // do whatever
}

foo(const char *c_str) {
  foo(std::string(c_str));
}

I look at this code and think it needs to be rewritten to pass by reference. Basically, my fear is that the constructor will get called twice, once in the const char * version of foo and once again when the argument is passed to foo as a std::string, since it is set to pass by copy. My question is: am I right, or is g++ smart enough to take the constructor in the c string version and call it good? It seems like g++ wouldn't be able to do that but I'm just hoping someone who really knows can clarify it.

My fear would be if I changed it to pass by reference, the thing I was referencing could be changed.... — Tony Hopkinson, May 19 '14 at 23:13

Matteo Italia · Accepted Answer · 2014-05-20T10:21:08.553

1

In theory two constructors (one to create the temporary, plus the copy constructor for the pass-by-copy) would be involved; in practice, the compiler is explicitly allowed to perform copy elision (C++11 §12.8 ¶32).

But you don't need the two overloads to begin with.

The normal way to go is to just have a version of that function that takes a const std::string &. If the caller already has an std::string, no copy is performed, since we are passing by reference. If instead it has a char *, a temporary std::string is created (since it has a non-explicit constructor from const char*) and is passed to the function (since const references can be bound to temporaries).

edited May 20 '14 at 10:21

answered May 19 '14 at 23:19

Matteo Italia

123,740
17
206
299

The compiler is allowed to elide copies even if the constructor has side effects. – Richard Hodges May 20 '14 at 00:15
@Richard: with RVO and NRVO of course, with parameters not that I know. – Matteo Italia May 20 '14 at 05:05
the same mechanism can be used to elide copies any time the source of the copy is not bound to a name. I.e. It's a temporary – Richard Hodges May 20 '14 at 07:45
@RichardHodges: I just checked the standard and you are correct (it's at C++11 §12.8 ¶32, third bullet point); I'll fix my answer. – Matteo Italia May 20 '14 at 10:19
it's an easy detail to miss. I had to read it twice before I saw it. – Richard Hodges May 20 '14 at 12:08

score 0 · Answer 2 · edited May 23 '17 at 12:20

you can just idiomatically write

foo (std::string const& str) {
  // do whatever
}

No need for the overload, since you can implicitly construct a temporary:

foo("yes");

If you intend to store the value of the argument somewhere, you could take an rvalue reference:

foo (std::string && str) {
   my_member = std::move(str);
}

But to avoid overload explosion, taking the argument by value is often a good middleground:

How true is "Want Speed? Pass by value"

Regardless of all this good avice about idomatic parameter-passing, yes the compiler can optimize away the spurious copies under the as-if rule (although the copy constructor is required to be accessible as if the copy were performed)

score 0 · Answer 3 · answered May 19 '14 at 23:14

Since the temporary passed to foo is unnamed it seems like it would be a fairly simple optimization to construct directly into the parameter, eliminating the copy, although this isn't guaranteed by the standard (as no optimizations are).

More generally speaking however, you should pass by constant reference unless your function would be taking a copy of the parameter itself already (perhaps to copy-and-mutate for example),

Pass By Copy Implications

3 Answers3