Re: Overload = and [ ] to store complex value terms in class

From:

Gianni Mariani <gi4nospam@mariani.ws>

Newsgroups:

comp.lang.c++

Date:

Sun, 06 Apr 2008 20:48:02 GMT

Message-ID:

<47f93700$1@news.mel.dft.com.au>

jwest wrote:

On 2008-04-06, joe <joeycook@mail.com> wrote:

         adaptor & operator = ( const std::complex<double> & val ) const
         {
            v.real_data[index] = val.real();
            v.imag_data[index] = val.imag();

---> return *this;

}

This example is well more thought out than mine. (Disregard mine in
favor of Gianni's version). Except for the above correction; although
I think I prefer the adapter's operator just to return 'val'

I'll change a statement in my OP a bit. This wasn't beyond my ability,
this was WAY beyond my ability :). Thank you both very much. I'll get it
implemented in the code with a citation to your posts on Google. The
class will primarily be used by engineering students with most of their
programming experience in Matlab, so I'm pretty confident that making
access look as much like access to a standard array/vector will ultimately
save us a lot of time in the future.

I just took another squiz at the code - I left out an explicit on the
constructor as well.

You can also add "iterator" support to this which would then make it
work with many of the standard algorithms as well.

#include <complex>
#include <valarray>

class COMPLEX_DATA {
     std::valarray<double> real_data, imag_data;
public:

     explicit COMPLEX_DATA(std::size_t size)
       : real_data(size), imag_data(size)
     {}

     class adaptor {
         COMPLEX_DATA & v;
         const std::size_t index;

         public:
         adaptor( COMPLEX_DATA & v, std::size_t index )
           : v(v), index(index) {}

         const adaptor &operator=(const std::complex<double> & val) const
         {
            v.real_data[index] = val.real();
            v.imag_data[index] = val.imag();
            return * this;
         }

         operator std::complex<double> () const
         {
            return std::complex<double>(
                v.real_data[index], v.imag_data[index] );
         }
     };

     const std::complex<double> operator[](std::size_t index) const
     {
        return std::complex<double>(
            real_data[index], imag_data[index] );
     }

     const adaptor operator[](std::size_t index)
     {
        return adaptor(*this, index);
     }
};

// "compile" test code

void f(COMPLEX_DATA & d)
{
    std::complex<double> v(1,1);

    d[2] = v;

    v = d[2];
}

void y(const COMPLEX_DATA & d)
{
    std::complex<double> v(1,1);

    // d[2] = v; -- error - can't assign to const

    v = d[2];
}

COMPLEX_DATA d(30);

int main()
{
   f(d);
   y(d);

   std::complex<double> v(1,1);
   std::complex<double> u(2,1);
   (d[3]=u)=v;
}