Re: [eigen] operator overloading vs expression templates, and the need to return references

[Benoit Jacob <jacob.benoit.1@xxxxxxxxx>]

2009/9/11 Rohit Garg <rpg.314@xxxxxxxxx>:
> Hi all,
>
> I made a simple class wrapping vector8s (for shorts) and overloaded
> the arithmetic and overloaded operators. All was fine until my
> expressions involving operator overloads got a bit too big and gcc
> started spewing random crap. It may not be random crap, but I can
> barely decipher it, so... :(
>
> I resorted to simplifying my expressions, and the code quickly
> exploded in verbosity with temporaries, but it compiled OK. Then I
> made all the overloads return a reference like this,
>
>  inline vector8s&  operator+(vector8s &other)
>        {
>        vector8s temp;
>        temp.data=_mm_add_epi16(data,other.data);
>        return temp;
>        }
>
> and it complies, but it throws warnings at each of these overloaded
> functions that I am returning references to temporaries. The
> overloaded functions are pretty small, hence inlined, so I think it
> should not be a problem, but it is obviously not nice.
>
> This naturally raises the question how expression templates avoid this
> problem, or how eigen suppresses these warnings, if indeed those
> warnings are in the safe-to-ignore category. If indeed the
> reference-to-temporary warnings can be safely ignored, then can anyone
> explain to me how to do it?

First of all, here, expression templates allow to completely avoid
this problem. Eigen isn't suppressing warnings here, and this isn't a
place where Eigen has to deal with reference-to-temporary issues. It's
a completely separate issue.

Looking back at your code:

>  inline vector8s&  operator+(vector8s &other)
>        {
>        vector8s temp;
>        temp.data=_mm_add_epi16(data,other.data);
>        return temp;
>        }

The way that expression templates work, is that the operator+ does NOT
do any computation, it does NOT return the computed result. Instead,
it returns an object that describe the addition operation
abstractly,and then when the user does c = a+b the actual computation
will be done by operator=. So the prototype is a bit like this:

Sum<T,OtherT> operator+(const OtherT& other)
{
  return Sum<T,OtherT>(*this, other);
}

Then all the job is done by an operator= that takes a const
Sum<T,OtherT>& as argument.

This is actually explained here:
http://eigen.tuxfamily.org/dox/InsideEigenExample.html#ConstructionOfSumXpr

Benoit