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

[ Thread Index | Date Index | More Archives ]

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;
>        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;
>        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:


Mail converted by MHonArc 2.6.19+