Re: extern const variable in case label
On Oct 6, 5:41 pm, Hendrik Schober <spamt...@gmx.de> wrote:
James Kanze wrote:
[...] Basically,
it's an optimization; what std::vector<>::push_back needs is an
object. It's passed as a const reference, rather than by value,
for purely optimization reasons. One could argue that 1) this
is premature optimization, and 2) in the case of things like
std::vector<int> or std::vector<double>, it's pessimization, and
that statistically, these are probably the most likely cases
when performance is an issue.
Since this question came up just a few hours ago:
On my platform (Win32) 'double' is bigger than a 'double&'.
We were discussing whether having to pass less bits to a
function would outweigh the additional indirection. So far
I had assumed that, in general, passing built-in types by
value is the best bet.
What's the foundation of your argument above?
Which argument? That it's premature optimization? Or that it
might actually be pessimization in some very frequent cases?
In all cases, of course, it depends on the machine. (On my
machine, the first five words of non-class types are passed in
registers.) And what you are doing; if you're passing a
literal, for example, the pass by reference means that the
compiler must first generate a temporary, and put the value
there; if you're passing four of them, the fact that a double
requires two registers on my machine (in 32 bit mode) means that
some spill into memory with pass by value, none of the addresses
do with pass by reference. That's all before the optimizer
kicks in, of course. Until you've done the actual measurements,
you don't know. (And of course, you won't bother doing them
unless you have an actual performance problem.)
Note too that I said explicitly "one can argue". What I've just
presented is only one side of the argument. The "premature
optimization" argument, for example, must be considered in view
of the fact that implementors can't change the interface
specified in the standard if they do have performance problems,
and because it's a library, probably can't even really measure
actual use, and have to make some guesses. And in this case,
pass by reference can maybe be viewed as legitimate dammage
control; regardless of the variation, it shouldn't kill you for
the basic types, and avoids an extra copy if the types are
expensive to copy. (I don't really buy this latter argument,
since std::vector will do a bit of copying anyway. Value
semantics should imply cheap to copy, or there's a problem with
the design.)
--
James Kanze (GABI Software) email:james.kanze@gmail.com
Conseils en informatique orient=E9e objet/
Beratung in objektorientierter Datenverarbeitung
9 place S=E9mard, 78210 St.-Cyr-l'=C9cole, France, +33 (0)1 30 23 00 34