Thread: Overloading ==

This is driving me nuts and I'm here at work without my books to help out. For some reason I thought that one didn't need to overload the "==" operator when comparing two objects of the same class but I get an error saying that it isn't defined with left hand operator of myclass. So I tried overloading the operator in the class but I must be doing something wrong because it just becomes circular. Here is what I have:

Code:

bool board::operator ==(board& b)
{
	return (*this==b);
}

I have a feeling its something real easy to fix but for the life of me I can't figure it out.

how about return (privatemember1==b.privatemember1)&&(privatemember 2==b.privatemember2)&& so on;

You dont have to as members of the class ie bool operator ==(const class&)const has direct access to all private members so its just a case of ensuring that all data members are equal then returning true else return false. The logical && way is best as it offers short circuit evaluation returning false as soon as a condition is not met. So its reasonably efficient.

When you are overloading the == operator, you should use the == operator, to compare the data members of the class( which are built-in types ), and ofcourse return a bool, for example:

Code:

class myClass {
public:
     bool operator==( myClass &) const;
     //more members
private:
     int value1;
     int value2;
};

//definition of the operator==
bool myClass::operator==(myClass &right ) const{
{
     if ( value1 == right.value1 && value2 == right.value2 )
          return true;
     return false;
}

Hope it's clear now...

Originally posted by PJYelton
>>I'm not sure, and I'm still learning, but can you do something like this?<<

No, that was what I was doing wrong. You basically end up with an unintentional recursive function that keeps calling itself over and over again because it keeps seeing the '=='!

That's the whole idea, that's why I said in my post:

you should use the == operator, to compare the data members of the class( which are built-in types ),

Shouldn't the == operator accept two arguments and not one? I've always seen == overloaded like this:

Code:

bool operator == (const myClass &lhs, const myClass &rhs)
{
	if(lhs.datamember1 == rhs.datamember1 && lhs.datamember2 == rhs.datamember3)
		return true;
	return false;
}

How should == be overloaded and why should it be done that way?

Originally posted by joshdick
Shouldn't the == operator accept two arguments and not one? I've always seen == overloaded like this:

Code:

bool operator == (const myClass &lhs, const myClass &rhs)
{
	if(lhs.datamember1 == rhs.datamember1 && lhs.datamember2 == rhs.datamember3)
		return true;
	return false;
}

How should == be overloaded and why should it be done that way?

The overloaded == function should be a member function, because the left most operand is an object if the class you are overloading the == operator for it.

The call the compiler will generate is like this:
if you have:

Code:

object1 == object2;
//the compiler will generate the following:
object1.operator==(object2);

So it should be implemented as a member function...
The code you wrote implements it as a friend, and I'm not sure if it is going to work, because I didn't test it, but even if it does, you should not use it, because whenever you can use a member function you should not use a firend...

Note:
If you didn't get it, just tell me, I'll be glad to help...

Code:

bool SomeClass::operator == ( const SomeClass& other ) const
{
	if( this->Data == other.Data ) 
	{
		return true;
	}
	else
	{
		return false;
	}
}

Note the consts. Data is a primitive member of SomeClass. Obviously, all members that need to be checked should be included in this statement.

Originally posted by ammar
The code you wrote implements it as a friend, and I'm not sure if it is going to work, because I didn't test it, but even if it does, you should not use it, because whenever you can use a member function you should not use a firend...

Note:
If you didn't get it, just tell me, I'll be glad to help...

Thanks for the offer of help. My confusion stems from the examples provided in my textbook. In those examples, arithmetic operators (+-*/), bool operators(==, >, etc.), and input/output of classes are done outside of the class as free (non-member) functions I looked through the whole textbook but couldn't find anything about the reserved word friend

Could you please explain it to me a bit, give a short example, when it should be used, and tell me why a member function is better than a friend function? I would really appreciate your help on this. I'm starting to write some classes on my own, and I don't want to screw them all up. Thanks in advance.