none <mikem...@hotmail.com> wrote:

And I have added this assignment operator as a member
of the class:

inline Ccomplex<COMPLEXTYPE> operator =3D (COMPLEXTYPE source)
{
=A0 this->real =3D source;
=A0 this->img =A0=3D 0;

=A0 return *this;
}

Why are you throwing away the imaginary part? Why all the copies? Why
even write the function when the compiler supplied op=3D does the right
thing?

none <mikem891@hotmail.com> wrote:

for example:
template <class COMPLEXTYPE, typename TYPENAME>
class Ccomplex

In that context, there is no difference between the keyword "class" and
the keyword "typename". I use typename because it is linguistically more
accurate.

none <mikem...@hotmail.com> wrote:

As a style issue. I find it odd that you abbreviate imaginary to img and
yet use COMPLEXTYPE which is usually abbreviated to just T, Ty, or Type.
Also, using two Cs in the name of the class is confusing, just call it
"Complex" not "Ccomplex".

Lastly, at least look at the official interface for the standard complex
class:

http://www.dinkumware.com/manuals/default.aspx?manual=3Dcompleat&page=3Dc.=

ex.html#complex

template <class COMPLEXTYPE>
class Ccomplex
{
=A0public:
=A0 =A0COMPLEXTYPE real;
=A0 =A0COMPLEXTYPE img;

=A0 =A0// Constructor

Redundant comment, of course the member-function is a constructor.

=A0 =A0Ccomplex (void)

Remove "void" above. It is unnecessary.http://www.parashift.com/c++-faq-li=

=A0 =A0{
=A0 =A0 real =3D 0;
=A0 =A0 img =A0=3D 0;
=A0 =A0}

Get in the habit of using initializer lists instead of assignment in the
body of the constructor.http://www.parashift.com/c++-faq-lite/ctors.html#f=

=A0 =A0// Constructor (conversion operator)

Redundant comment...

=A0 =A0Ccomplex (COMPLEXTYPE val)
=A0 =A0{
=A0 =A0 real =3D val;
=A0 =A0 img =A0=3D 0;
=A0 =A0}

What about a two argument constructor? That would make sense...

=A0 =A0// Destructor
=A0 =A0~Ccomplex (void) { }

The compiler provides a destructor that does exactly what yours does. So
remove yours and let the compiler do its job.

=A0 =A0inline Ccomplex<COMPLEXTYPE> operator =3D (Ccomplex<COMPLEXTYPE>
source);

The compiler provides an op=3D that does exactly what yours does. So
remove yours and let the compiler do its job.

=A0 =A0friend inline Ccomplex<COMPLEXTYPE> operator + \
=A0 =A0 =A0 =A0 =A0 =A0 =A0 =A0 (Ccomplex<COMPLEXTYPE> dest, Ccomplex<CO=

source);
=A0 =A0friend inline Ccomplex<COMPLEXTYPE> operator + \
=A0 =A0 =A0 =A0 =A0 =A0 =A0 =A0 (Ccomplex<COMPLEXTYPE> dest, const COMPL=

source);
=A0 =A0friend inline Ccomplex<COMPLEXTYPE> operator + \
=A0 =A0 =A0 =A0 =A0 =A0 =A0 =A0 (const COMPLEXTYPE dest, Ccomplex<COMPLE=

source);

The backslash isn't necessary in the above (or anywhere else if this
program for that matter. Don't complicate your life by using unnecessary
constructs.

"friend" isn't necessary. There is nothing private/protected in the
class.

"inline" isn't necessary. The compiler will inline where it can.

The three declarations above aren't necessary.

=A0protected:

Spurious access specifier.

};

typedef Ccomplex<double> COMPLEX;

Reserve all upper-case declarations for macros.

template <class COMPLEXTYPE>
inline Ccomplex<COMPLEXTYPE> \
=A0 =A0 =A0 =A0Ccomplex<COMPLEXTYPE>::operator =3D (Ccomplex<COMPLEXTYPE=

source)
{
=A0 this->real =3D source.real;
=A0 this->img =A0=3D source.img;
=A0 return *this;
}

template <typename COMPLEXTYPE>
inline Ccomplex<COMPLEXTYPE> operator + \
=A0 =A0 =A0 (Ccomplex<COMPLEXTYPE> dest, Ccomplex<COMPLEXTYPE> source)

'dest' and 'source' are misleading names for the arguments.

{
=A0 Ccomplex<COMPLEXTYPE> newdest;
=A0 newdest.real =3D dest.real + source.real;
=A0 newdest.img =A0=3D dest.img =A0+ source.img;
=A0 return newdest;

If you make a two argument constructor, the above can be made much
simpler...

=A0 =A0return Complex<T>( left.real + right.real, left.img + right.img );

}

template <typename COMPLEXTYPE>
inline Ccomplex<COMPLEXTYPE> operator + \
=A0 =A0 =A0 (Ccomplex<COMPLEXTYPE> dest,const COMPLEXTYPE source)
{ return dest + (Ccomplex<COMPLEXTYPE>) source; }

Better to call the conversion constructor explicitly.

template <typename COMPLEXTYPE>
inline Ccomplex<COMPLEXTYPE> operator + \
=A0 =A0 =A0 (const COMPLEXTYPE dest, Ccomplex<COMPLEXTYPE> source)
{ return (Ccomplex<COMPLEXTYPE>) dest + source; }

const is unnecessary as used above. Generally, declaring arguments
"const type" is considered bad form. Pass the arguments either by value,
or by const reference.

int main(int argc, char* argv[])

If you don't use the arguments, don't put them in.

{
=A0 =A0 COMPLEX complex;
=A0 =A0 COMPLEX complex2;

=A0 =A0 complex.real =3D 5;
=A0 =A0 complex.img =A0=3D 2;

=A0 =A0 // WORKS
=A0 =A0 complex2 =3D (COMPLEX) 1 + complex;
=A0 =A0 complex =A0=3D complex2 + (COMPLEX) 2;

Prefer calling the conversion constructor explicitly instead of using a
cast.

=A0 =A0 // WORKS but must use double notation to avoid
=A0 =A0 // template ambiguities between in and double
=A0 =A0 complex2 =3D 1.0 + complex;
=A0 =A0 complex =A0=3D complex2 + 2.0;

=A0 =A0 return 0;

"return 0;" from main is unnecessary.

}

So, if you accept all my changes, you end up with:

=A0 =A0template <class T>
class Complex
{
public:
=A0 =A0T real;
=A0 =A0T img;

=A0 =A0Complex(): real(0), img(0) { }
=A0 =A0Complex(T val): real(val), img(0) { }
=A0 =A0Complex(T real, T img): real(real), img(img) { }

};

=A0 =A0template <typename T>
Complex<T> operator +(Complex<T> left, Complex<T> right)
{
=A0 =A0return Complex<T>(left.real + right.real, left.img + right.img);

}

=A0 =A0template <typename T>
Complex<T> operator +(Complex<T> left, T right)
{
=A0 =A0return Complex<T>(left.real + right, left.img);

}

=A0 =A0template <typename T>
Complex<T> operator +(const T left, Complex<T> right)
{
=A0 =A0return Complex<T>(left + right.real, right.img);

}

typedef Complex<double> ComplexDouble;

int main(int argc, char* argv[])
{
=A0 =A0ComplexDouble complex;
=A0 =A0ComplexDouble complex2;

=A0 =A0complex.real =3D 5;
=A0 =A0complex.img =A0=3D 2;

=A0 =A0complex2 =3D ComplexDouble(1) + complex;
=A0 =A0complex =A0=3D complex2 + ComplexDouble(2);

=A0 =A0complex2 =3D 1.0 + complex;
=A0 =A0complex =A0=3D complex2 + 2.0;



}- Hide quoted text -

- Show quoted text -

I would also like to be able to do

foo fooobj,fooobj2;
fooobj = integer + fooobj2;

but I can't find a way to do this, the only overloads I
was able to make is:

foo fooobj,fooobj2;
fooobj = fooobk + integer;

and

foo fooobj,fooobj2;
fooobj = fooobj + fooobj2;

I would also like to be able to do

foo fooobj,fooobj2;
fooobj = integer + fooobj2;

but I can't find a way to do this, the only overloads I
was able to make is:

foo fooobj,fooobj2;
fooobj = fooobk + integer;

and

foo fooobj,fooobj2;
fooobj = fooobj + fooobj2;