Re: Speed of passing a string by value vs. const reference
On Thu, 30 May 2013 17:55:04 -0700 (PDT)
SG <s.gesemann@gmail.com> wrote:
On May 30, 3:28 pm, Andreas Dehmel wrote:
On Thu, 30 May 2013 02:06:37 -0700 (PDT)
SG <s.gesem...@gmail.com> wrote:
On May 29, 11:46 pm, James Kanze wrote:
The ubiquitous rule is to pass class types by reference to
const, other types by value. Since std:;string is a class typ=
e,
convention says to pass it by reference to const, even if with a
well written string class, it won't make a significant
difference.
Some rules are now outdated in the light of move semantics.
Nonsense. For container types, a move still implies swapping at
least 2-3 pointer-sized members and while this is certainly orders
of magnitude faster than copying the whole thing, there's no way
this'll be faster than simply dereferencing a pointer.
Compare
string flip(string const& cref) {
string result = cref; // explicit copy,
// might be unnecessary
reverse(result.begin(),result.end());
return result; // NRVO applicable
}
with
string flip(string temp) { // temp might be move-constructed or
// even constructed directly via
// copy/move elision
reverse(temp.begin(),temp.end());
return temp; // implicitly moved
}
You're not measuring the overhead of passing the argument one way
or another but the copy constructor in the first case, which is
a completely different issue that can easily be avoided by using
string result(cref.rbegin(), cref.rend()) rather than call reverse
on a copy. I'd call this a pathological textbook example with zero
practical relevance; one can always construct these, that doesn't
mean anything. Plus moving the argument in the second case will
not be possible if you don't call the function with a temporary,
so performance will vary considerably for rather obscure reasons
(and still be slower when not calling with a temporary).
Andreas
--
Dr. Andreas Dehmel Ceterum censeo
FLIPME(ed.enilno-t@nouqraz) Microsoft esse delendam
http://www.zarquon.homepage.t-online.de (Cato the Much Younger)