Re: pros and cons of returning const ref to string instead of string by value
Apart from performance (by-value can be faster as pointed out inhttp://cpp-next.com/archive/2009/08/want-speed-pass-by-value/) the
simplest argument for by-value is elegance and clarity.
string process( string name, string content );
simply reads smoother than
string const& process( string const& name, const string &
content );
There is a general best-practice statement in programming that one
should avoid premature optimization. You may consider your case a good
example of this practice. First pass by value (it is clearer, safer
(dangling refs, multithreading), shorter) and if you find that
performance is insufficient, and if you measure that substituting by-
ref increases performance significantly (and it may not), only then
should you change to by-ref.
The general principle is sound but this is taking it too far.
Passing by const reference is idiomatic in C++ - particularly for
strings - so it is not really much clearer.
Also the optimisation is not premature if you are writing a general
purpose function/library - If your process function MIGHT be used by
someone else passing a 10Mb string then your failure to pass by const
reference could well mean that they have to write their own function
rather than use yours.
This is why almost all templates pass by const reference.
Hi,
I tend to agree with you. Obviously, I also pass by-ref, but when the
objects are not meant to be values, like polymorphic classes, or when
the structure of the code is so complicated that I cannot tell what
the consequence of passing by-val would be.
However, I find it appropriate to provide a list of arguments that one
should consider before applying the otherwise good practice of passing
by-ref. This is mostly the arguments already given in this topic:
(1). There is a family of cases where passing by-value is faster than
passing by-ref. This is somewhat counter to intuition, but still true.
The link to the explanation has already been provided a couple of
times.
(2). With the addition of rvalue-references (some compilers implement
it, some libraries emulate it), the family of cases where by-val is
faster increases.
(3). Passing by-val automatically protects against concurrent access
in multi-threaded programs.
(4). Passing by-val automatically protects against advertent or
inadvertent aliasing (even in single-threaded programs).
(5). Passing "by value" doesn't mean passing "by copy". The compiler
simply guarantees that if the called function modifies the parameter,
it is not reflected in the argument provided by the caller. The
compiler may use the copy to provide this guarantee, but it may as
well not. After all the compilers are designed to provide as good
binaries as possible.
(6). Passing by const-ref has its original meaning, already forgotten
due to this optimization technique. It used to mean that there is an
external object that we want to observe, that may change while we are
observing it, and that we do not intend to modify ourselves; e.g
listening on the port:
void observe( Port const& port ) {
while( ... ) {
if( port.value() != prev_value ) {
prev_value = port.value();
process( prev_value );
}
}
}
(7). The following call std::max("me", "you"); doesn't compile due to
the arguments being references rather than values. I know it might
have little sense if it compiled, but just for the argument's sake.
(8). In generic templates we use little if we pass arguments by value
as we can always use boost::ref (and now also std::tr1::ref, I think)
to force by-ref.
(9). Once I learnt that I started passing strings by-val in the
commercial code I am working with. The strings in my application are
short: no longer than 100 chars, and most often around 12 chars. I
observed no slowdown whatsoever.
Regards,
&rzej
--
[ See http://www.gotw.ca/resources/clcm.htm for info about ]
[ comp.lang.c++.moderated. First time posters: Do this! ]