CODEWITHSUNDEEP
c++operator-overloading
interstar
interstar

Reputation: 27186

C++ overloading the equality operator. Should I write my function to accept argument passed by reference or value?

I want to overload the == operator for a simple struct 

struct MyStruct {
public:
   int a;
   float b;
   bool operator==( ) {  }
}

All the examples I'm seeing seem to pass the value by reference using a &.

But I really want to pass these structs by value.

Is there anything wrong with me writing this as 

bool operator== (MyStruct another) { return ( (a==another.a) && (b==another.b) ); }

Upvotes: 0

Views: 49

Answers (2)

SergeyA
SergeyA

Reputation: 62563

While being consistent is laudable goal, one shouldn't overdo it. A program containing only 'A' characters would be very consistent, but hardly useful. Argument passing mechanism is not something you do out of consistency, it is a technical decision based on certain technical aspects.

For example, in your case, passing by value could potentially lead to better performance, since the struct is small enough and on AMD64 ABI (the one which is used on any 64bit Intel/AMD chip) it will be passed in a register, thus saving time normally associated with dereferencing.

On the hand, in your case, it is reasonable to assume that the function will be inlined, and passing scheme will not matter at all (since it won't be passed). This is proven by codegen here (no call to operator== exist in generated assembly): https://gcc.godbolt.org/z/G7oEgE

Upvotes: 1

Pavan Manjunath
Pavan Manjunath

Reputation: 28525

It should really not matter expect that you pay the penalty of a copy when you pass by value. This applies if the struct is really heavy. In the simple example you quote, there may not be a big difference.

That being said, passing by const reference makes more sense since it expresses the intent of the overloaded function == clearly. const makes sure that the overloaded function accidentally doesn't modify the object and passing by reference saves you from making a copy. For == operator, there is no need to pass a copy just for comparison purposes.

If you are concerned about consistency, it's better to switch the other pass by value instances to pass by const ref.

Upvotes: 1

Related Questions