Having issues with overloading C++ operators

Question

I'm having some issues understanding this concept. In the main.cpp file, we have a function as follows:

void TestComparison()
{
    MyFloat X, Y;

    cout << "\n\n============  Testing \"==\"  for MyFloat  ================\n";

    do
    {
        cout << "\nEnter X  ==> ";
        X.Read();
        cin.ignore(1000, '\n');             //  Discard all chars in input stream.
        cout << "\nEnter Y  ==> ";
        Y.Read();
        cin.ignore(1000, '\n');             //  Discard all chars in input stream.

        cout << "\n\n";

        if ( X == Y )
        {
            X.Write(); cout << " is equal to "; Y.Write();
        }
        else
        {
            X.Write(); cout << " is NOT equal to "; Y.Write();
        }
    }
    while ( SpaceBarToContinue() );
}

This is the class I'm writing:

class MyFloat
{
    enum {MAXDIGIT=20};
    char Number[MAXDIGIT+1];
    char NumberOfDigits;

public:

    friend void AssignValue(MyFloat& X);//remove after the program works

    MyFloat();

    int Digits();
    int MaxDigits();
    void Read();
    void Write();

    MyFloat operator + (MyFloat x);
    int operator== (MyFloat x);
};

Here is my == overload function stub:

int MyFloat::operator== (MyFloat x)
{
    int Flag=0;

    return 1;
}

The only purpose of this is to compare two an array of objects X and Y. They are passed into a == overloaded function. I'm supposed to write the algorithm that compares them. I know how to write the algorithm that compares these two character arrays, thats not the issue, but what I'm failing to understand is how both X and Y get into the the overloaded function to compare them? In the main, the code ( X == Y ) is used to obtain a 0 or 1. How are X and Y passed into the function?

For instance, I would assume my function stub would need to be rewritten with 2 parameters:

int MyFloat::operator== (MyFloat x, MyFloat y)
{
    int Flag=0;

    return 1;
}

But doing this produces an error back in the main during the function call of ( X == Y ) that states 'Overload "operator==" must be a binary operator (has 3 parameters)'

So I'm totally confused on how to get both Objects of MyFloat into the function to compare them. I'm still fairly new to programming (5-6 months of learning), any plain and simple answers are greatly appreciated.

Answer 1

When you write:

if(a == b)

what it really means is:

if(a.operator==(b))

So in your method:

bool MyFloat::operator==(const MyFloat &x) const
{
    // x is b in call above
    // (*this) is a in call above

    // Your class invariant should guarantee this:
    // assert(x.NumberOfDigits < MAX_DIGITS);

    // In the scope of your class' methods:
    //   NumberOfDigits corresponds to this->NumberOfDigits
    //   Number corresponds to this->Number
    if(x.NumberOfDigits != NumberOfDigits) return false;
    // Same as: if(x.NumberOfDigits != this->NumberOfDigits) return false;
    return strncmp(x.Number, Number, NumberOfDigits) == 0;
    // Same as: return strncmp(x.Number, this->Number, this->NumberOfDigits) == 0;
}

Note that I changed the signature of your method. The correct signature returns a bool and takes a const (because you don't want to change the parameter) reference (avoid copying a big object) as parameter. The method is (and must be) const because it's not supposed to modify the object and it must be callable on a const object.

Note that it is possible to define the operator as a non-member function (i.e outside of the class) with the following signature:

bool operator==(const MyFloat &a, const MyFloat &b)

Answer 2

You should use this pointer. For more information: Source

bool MyFloat::operator==(const MyFloat& x) const
{
    for(int i = 0; i < x.MaxDigits; ++i)
    {
        if(x[i] != (*this)[i])
            return false;
    }
    return true;
}

Answer 3

member functions (including overloaded operators) have an implicit this parameter passed in. In your case since you are using a member version of operator== you should only need one parameter the other is this.