Operator overloading in C#

Question

        [Serializable]
        public class ComplexArray
        {
            #region Attributes

            /// <summary>
            /// Array Size
            /// </summary>
            protected int m_iSize;

            /// <summary>
            /// Real part of the data
            /// </summary>
            protected double[] m_dReal;

            /// <summary>
            /// Imaginary part of the data
            /// </summary>
            protected double[] m_dImag;

            #region Construction

            /// <summary>
            /// Default constructor
            /// </summary>
            public ComplexArray()
            {
            }


            public override bool Equals(object o)
            {
                if (this == (ComplexArray)o)
                    return true;
                else
                    return false;
            }



            public static bool operator ==(ComplexArray src1, ComplexArray src2)
            {
                if (src1.m_iSize != src2.m_iSize)
                    return false;

                for (int ii = 0; ii < src1.m_iSize; ii++)
                {
                    if (src1.Real[ii] != src2.Real[ii])
                        return false;
                    if (src1.Imag[ii] != src2.Imag[ii])
                        return false;
                }

                return true;
            }

            public static bool operator !=(ComplexArray src1, ComplexArray src2)
            {

                if (src1 == src2)
                    return false;
                else
                    return true;
            }

    }

I have a created a class called complex array and intention of this class is to save real and imaginary numbers and different operators have been overloaded like +,*,!=,==

Assume some function returns the instance of this class.

ComplexArray array = GetValue();

I want to check whether the reference is valid or not...

    if(array != null)
    {
      //proceed further....
    }

Issue : When the value is checked against null value, the exception occurs, because internally != overloaded function calls the ==.

How to avoid this kind of situation in operator overloading? Or how to make the operator != or == to check for the null value and return the correct values(true or false)

Answer 1

如果可以以.NET Framework 4.0为目标，则System.Numerics.Complex看起来像您所需要的。

Answer 2

Inside the == and != overloaded operators (at the very top) put the following:

if (src1 == null || src2 == null)
    return false;

By the way, I find your complex number implementation is kind of poor. You could use some ready example or at least read it through.

Answer 3

This can be done by this code:

public override bool Equals(object obj)
{
    var other = obj as ComplexArray;

    if(ReferenceEquals(other, null))
    {
        return false;
    }

    if(ReferenceEquals(this, other)
    {
        return true;
    }

    // ToDo: Do all other comparision beyond reference comparision.
}

Also within the == operator you have to check both sides:

public static bool operator ==(ComplexArray src1, ComplexArray src2)
{
    if(ReferenceEquals(src1, null)
       || ReferenceEquals(src2, null))
    {
        return ReferenceEquals(src1, src2);
    }

    return src1.Equals(src2);
}

public static bool operator !=(ComplexArray src1, ComplexArray src2)
{
    return !(src1 == src2);
}

And don't forget, if you override Equals() you have also to override GetHashCode() . A good pattern for doing can also be found on SO .