Re: Temporary objects and operators overloading

From:

Francis Glassborow <francis.glassborow@btinternet.com>

Newsgroups:

comp.lang.c++.moderated

Date:

Mon, 6 Jul 2009 11:30:36 CST

Message-ID:

<ZsadnZng6OVzkc_XnZ2dnUVZ8nednZ2d@bt.com>

Seungbeom Kim wrote:

SG wrote:

     class Overloading {
      [...]
        Overloading& operator+=(Overloading const& rhs)
        {
           this->a += rhs.a;
           return *this;
        }
      [...]
        friend Overloading operator+(Overloading const& lhs,
           Overloading const& rhs)
        {
           Overloading result = lhs;
           result += rhs;
           return result;
        }
     };

If my memory serves me correctly, a better way to write operator+ is:

    friend Overloading operator+(Overloading lhs, Overloading const& rhs)
    {
        lhs += rhs;
        return lhs;
    }

because the compiler can recognize if the actual argument for lhs
is a temporary, in which case it can skip a copy construction.

(You may also want different overloads on each parameter being an
rvalue reference or an lvalue reference, in the era of C++0x...
but I'm not an expert in that new feature.)

Why do you need friendship? As long as operator +=() has been provided
as a class member the free function does not need access to the private
data.

In addition consider
Overloading operator+(Overloading const & lhs, Overloading const & rhs){
     Overloading result(lhs);
     return result += rhs;
}

Which retains the symmetry of lhs and rhs. And a halfway decent compiler
will construct the copy of lhs in the return space and then increment it
by adding rhs.

--
      [ See http://www.gotw.ca/resources/clcm.htm for info about ]
      [ comp.lang.c++.moderated. First time posters: Do this! ]