== Overloading return expression

Question

0.00/5 (No votes)

See more:

Here's a short snippet from a search program. I had one doubt about this.
What is x.the_key is being used for? Why can't x and y be checked with x==y here?
Why do we have to the local copy of a key's value?

class Key()
{
public: Key(int x=0);
int the_key()const;
}
bool operator == (const Key &x, const Key &y) // == overloading
{
return x.the_key()==y.the_key(); // x.the_key?
}

Posted 30-Dec-10 22:39pm

optimus_prime1

Updated 2-Jan-11 7:33am

v6

Add a Solution

1 solution

Add a Solution

Add your solution here

Treat my content as plain text, not as HTML

Preview 0

…

Existing Members

Sign in to your account

...or Join us

Download, Vote, Comment, Publish.

Your Email
Password
Forgot your password?

Your Email
This email is in use. Do you need your password?
Optional Password

I have read and agree to the Terms of Service and Privacy Policy
Please subscribe me to the CodeProject newsletters

When answering a question please:

Read the question carefully.
Understand that English isn't everyone's first language so be lenient of bad spelling and grammar.
If a question is poorly phrased then either ask for clarification, ignore it, or edit the question and fix the problem. Insults are not welcome.
Don't tell someone to read the manual. Chances are they have and don't get it. Provide an answer or move on to the next question.

Let's work to help developers, not make them feel stupid.

This content, along with any associated source code and files, is licensed under The Code Project Open License (CPOL)

Manfred Rudolf Bihy · Accepted Answer · 2010-12-30T23:00:00

Solution 1

Comparing two objects via == is something different from comparing the content of these objects. Since you have shown us only the contract for class Key and not its implementation, I can only guess that the function int the_key() returns the integer value that is stored inside class Key.
Overloading the == operator is done here so you can compare the content of two instances of type Key as you would usually compare the two references to the respective instances.

Caveat!: Changing the semantic of the == operator is considered bad design! Please don't do that unless you have a very good reason.

At an superficial glance one would think that two references are being compared, but by overloading the == operator it is now a comparison of their content.
There must be a very, very good reason when this is done and it should be documented really well.

Best Regards,

Manfred

Posted 30-Dec-10 23:00pm

Manfred Rudolf Bihy

Updated 30-Dec-10 23:04pm

v3

Comments

optimus_prime1 31-Dec-10 5:26am

I am confused what's x.the_key(); doing?
int the_key()const; is only defined in the class .h file and there's no more mention of it in the example from a book I am trying the program. It only mentions the_key is being used to inspect a copy of key's value. A little bit more explanation would make this more clear to me.
Thanks!

CPallini 31-Dec-10 5:33am

Without implementation of the 'theKey' method the program can't compile and I don't know if it deserves further investigation.

Manfred Rudolf Bihy 31-Dec-10 5:45am

@CPallini: He said it's from a book so I take it that part may have been left as an exercise. We have to give this guy a break at least he is actually reading a book! :)

Manfred Rudolf Bihy 31-Dec-10 5:50am

@Optimus: x and y are the two operands of type Key for the == operator, so if one were to write the expression x == y what happens behing the scenes is that the function the_key() is called on both operands and the two values (here integers) are compared.
Since this was probably an example on operator overloading they left out the implementation details as they are easy to figure out.
Type Key needs a private field of type integer which is initialized in the constructor call. The function the_key() will return the value of said private instance variable.

Clearer now?

optimus_prime1 1-Jan-11 10:36am

Hi Manfred,
Thanks for being so cooperative and I really appreciate this. If you'll still allow me to ask, why can't we compare return (x==y) just like this. Why do we even need to use int the_key()const; ?

Manfred Rudolf Bihy 1-Jan-11 10:49am

As I stated in my last comment x and y are of type Key.
If you compare two instances (x==y) their references (aka pointers) are compared and two pointers are only equal if they point to the same object.
The example overloads above mentioned default behavior and compares the content. Instead of having a function you could have just made a public member variable called z. Then in the operator overload definition you'd have to write:

return x.z == y.z; //The operator inside the overload definition is compares the fields and not the objects.

optimus_prime1 2-Jan-11 10:54am

Ok, now I get this totally.
Thanks a lot for help!!

Manfred Rudolf Bihy 2-Jan-11 11:09am

Glad if I could help!

optimus_prime1 2-Jan-11 11:23am

uh! I can't format the comment above properly. :-(

Manfred Rudolf Bihy 2-Jan-11 11:41am

For some additions one makes it's better to modify your question as you have better formatting capabilities there. Then you just leave a short comment to the respective answers and they will get notified.