"ref const" parameters in functions

[Jonathan M Davis]

On Sunday, April 01, 2012 21:23:50 Jonathan M Davis wrote:
> On Monday, April 02, 2012 05:46:24 L-MAN wrote:
> Sure, if you have large structs, making a lot of copies of them can be
> expensive. But to avoid that, you're going to have to avoid coding in a way
> which creates temporaries, and expressions like
> 
> (abc1+abc2*20.0)+(abc1*abc2+abc1*20.0)
> 
> will _always_ create temporaries. The classic, arithmetic operators are
> classic examples of functions which create temporaries (all of which are
> rvalues). So, you can't code that way and expect to avoid temporaries.

I should point out that with optimizations turned on, in some cases the 
compiler can optimize out the copying of temporaries, though not generally the 
temporaries themselves. For instance

auto a = abc1 + abc2 * 20.0

results in a temporary for the result of * and a temporary for the result of 
+. But the temporary for the result of + will be optimized out (probably even 
without turning on optimizations), because you're using that result to 
initialize a variable. And while the result of * will result in a temporary, 
the copy that gets made when it's passed to opBinary!"+" should be optimized 
out when compiled with optimizations turned on. So, the optimizer should be 
able to reduce the problem a fair bit if you compile with -O. -inline may be 
able to reduce it even further. So, with optimizations turned on, you may not 
get anywhere near as many copies as you expected.

And using auto ref for the parameters (which is easy with the overloaded 
arithmetic operators, since they're already templated) should also help reduce 
the number of copies made, but it _is_ up to the compiler whether it makes a 
copy or not with auto ref, so that depends on the compiler.

So, you should be able to reduce the number of copies simply by compiling with 
-O and -inline, but the temporaries themselves will exist regardless.

- Jonathan M Davis