Re: Passing values by reference
On 22 Jan., 15:19, James Kanze <james.ka...@gmail.com> wrote:
More generally, C++ uses pass by value by default, and that's
what should be used unless there is a reason to do otherwise:
-- polymorphic objects,
-- the callee modifies the object
-- (premature?) optimization
In many ways, passing even something like std::string by const
reference when you really mean value is premature optimization.
On the other hand, of course, it is so ubiquious that you would
seem wierd not to do it. (Note that if the library uses the
small string optimization, and the compiler is really, really
good, passing short std::string's by reference may actually be
more expensive than passing them by value.)
The choice is not so easy IMHO -- especially if you want to write
generic code. I use a lot of const references in generic code because
someone might instantiate it with types that can't be copied cheaply.
It depends a lot on the types you deal with. Does the string
implementation make use of copy-on-write / small-string-optimization
or not? If I don't intend to modify a string I'd still use a const
reference regardless of the string's implementation. I don't think the
extra level of indirection is a big issue (I havn't measured it).
Still, call-by-value isn't as bad as many people think. There are
situations where the compiler can optimize many copies away. Example:
std::string source(); // returns an rvalue
void sink(std::string s); // pass by value
int main() {
sink(source());
}
A smart compiler could elide every string copy operation. It would
create the string in the function 'source' directly at the address of
sink's 's' (assuming a trivial source function). As far as I can tell,
G++ does this even without using any optimization compiler switches.
It's probably due to its ABI.
So, I'd stick to the following rules for deciding between pass-by-
value and pass-by-const-reference for non-polymorphic types:
(1) Use pass-by-value if you need to alter a local copy within your
function
(2) Use pass-by-const-reference for "big" objects you don't need to
modify. ("big" = creating a copy is expensive)
(3) If neither 1 nor 2 applies use pass-by-value.
Exploiting the G++ ABI you might even want to prefer
class Container {
A memb_;
public:
void replaceWith(A x) { memb_ = std::move(x); }
};
over
class Container {
A memb_;
public:
void replaceWith(A const& x) { memb_ = x; }
void replaceWith(A && x) { memb_ = std::move(x); }
};
in the future. :-)
Cheers!
SG