<p>I had assumed that the canonical form for operator+, assuming the existence of an overloaded operator+= member function, was like this:</p>

<pre><code>const T operator+(const T&amp; lhs, const T&amp; rhs)
{
    return T(lhs) +=rhs;
}
</code></pre>

<p>But it was pointed out to me that this would also work:</p>

<pre><code>const T operator+ (T lhs, const T&amp; rhs)
{
    return lhs+=rhs;
}
</code></pre>

<p>In essence, this form transfers creation of the temporary from the body of the implementation to the function call.</p>

<p>It seems a little awkward to have different types for the two parameters, but is there anything wrong with the second form?  Is there a reason to prefer one over the other?</p>

With the edited question, the first form would be preferred.  The compiler will more likely optimize the return value (you could verify this by placing a breakpoint in the constructor for T).  The first form also takes both parameters as const, which would be more desirable.
Research on the topic of
return value optimization
, such as this link as a quick example:
http://www.cs.cmu.edu/~gilpin/c++/performance.html