Re: Copy vs. const reference function argument
Przemyslaw Koprowski wrote:
On Wed, 26 Mar 2008 08:55:44 +1300, Ian Collins wrote:
I all depends how expensive a foo is to copy. The idiomatic form
would be cost&. If foo is small, it may be cheaper to pass by
value, but that would change if ever foo changed.
Why? After all, the foo object is being copied in both cases.
Either explicitely when constructing B:
foo someFunction(const foo& A)
{
foo B(A);
// do sth. to B
return B;
}
or implicitely when passing an argument by value:
foo someFunction(foo A)
{
// do sth. to A
return A;
}
That's why I don't expect any difference. Could you ellaborate
why size of foo shall matter here?
I think a common implementation of references for the purposes of
passing them as arguments is a pointer. IOW, behind the scenes the
compiler generates the code that passes the address of the object
when you write pass by reference. Unless the function is inlined,
passing an address requires for the item to be in memory. For some
cases it would actually be better to pass the argument itself if it
can be kept in a processor register (instead of storing it in memory
even if it's just in the stack). A long time ago, in a different
life, I timed calling an empty function that takes a double as its
argument, another that takes a reference to a double, and yet
another that takes a pointer to a double. With certain optimization
options the compiler generated the fastest code when the double was
passed by value. With other options the difference was not serious
enough to mention. YMMV
V
--
Please remove capital 'A's when replying by e-mail
I do not respond to top-posted replies, please don't ask