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
