Is it better to overload addition operator as non-member function?

Question

I have a Fraction class as following.

class Fraction
{
  int num, den ;

  public:
   //member functions here
} ;

I read in some book, I think 'effective c++' that it is better to overload the addition operator as non member function. The reason given there was that it allows commutative addition. This is the prototype of my overloaded function for addition operator.

Fraction operator + (const Fraction &obj, const int add_int) ;

Here, when i call it, I have to do it like this.

f1 + 2 ;

But it won't work this way.

2 + f1 ;

For that i would have to write the function again and change the order of parameters in that.

I want to know that whether there is a method by which I can overload function a single time and perform commutative addition?

You cannot have a single function which will support both the forms. You will have to provide free standing function overloads. `Fraction operator + (const Fraction &obj, const int add_int) ;` and `Fraction operator + (const int add_int, const Fraction &obj) ;` and that is the right way to go about it. — Alok Save, Aug 26 '12 at 14:35
Is there an implicit conversion from `int` to `Fraction`? If so, it can be done, if not it cannot. — David Rodríguez - dribeas, Aug 26 '12 at 14:39
You slightly misquote Effective C++. It actually states 'Declare non-member functions when type conversions should apply to all parameters'. — Johan Lundberg, Aug 28 '12 at 18:13
I reckon its some other book, if you are saying rightfully.. — Coding Mash, Aug 29 '12 at 09:18

Benjamin Lindley · Accepted Answer · 2012-08-26T14:56:17.617

5

You can, but only if your class has an implicit constructor from the type you want to add to, so this would work:

class Fraction
{
    int num, den;

public:
    Fraction(int n) :num(n), den(1) {}

    // member functions here
};

Fraction operator+(Fraction lhs, Fraction rhs) { ... }

int main()
{
    Fraction f1(5);
    f1 = f1 + 5;
    f1 = 5 + f1;
}

Of course, this allows a usage that you didn't actually mention you wanted, which is the ability to add two Fraction objects.

Fraction f1(1), f2(2);
Fraction f3 = f1 + f2

I can't imagine you would want to disallow that though.

edited Aug 26 '12 at 14:56

answered Aug 26 '12 at 14:38

Benjamin Lindley

101,917
9
204
274

Thanks for that. I had two objects added, the problem was just with the one I questioned. – Coding Mash Aug 26 '12 at 14:58

score 2 · Answer 2 · edited May 23 '17 at 11:49

2

Do these things:

Define a constructor Fraction(int) to enable implicit conversion from int to Fraction.
Define operator+=() as member function.

Then define operator+() in terms of operator+=() as:

Fraction operator+(Fraction f1, Fraction const & f2)
{
    f1 += f2;  //call `operator+=` member function
    return f1;
}

Note that f1 is passed by value. So you can add f2 to it, and return it.

For detail answer, see my answer here to a similar question:

Functions with return values (C++)

edited May 23 '17 at 11:49

Community

1
1

answered Aug 26 '12 at 14:38

Nawaz

353,942
115
666
851

Ok. But if I am doing implicit conversion, why do I have to overload += operator? – Coding Mash Aug 26 '12 at 14:45
@CodingMash: Because it make sense to have that overload. If you can do `f1 = f1+f2;` then why can't you do `f1 += f2;` also? They're the same thing, right? Go through the link provided in my answer; it explains them all. – Nawaz Aug 26 '12 at 14:47
I got that. What i want to say is that just for f3 = f1 + f2, i do not need to overload += operator? – Coding Mash Aug 26 '12 at 14:50
@CodingMash: But if you can do `f3=f1+f2`, then you can do also `f1 = f1+f2` which is same as `f1+=f2`. (Once again, I will advise you to read my answer in the other topic, it has all the explanation). – Nawaz Aug 26 '12 at 14:51
1

Ok Thankyou. I have got it.. Its this way that I can perform commutative addition, but not without implicit conversion.Right – Coding Mash Aug 26 '12 at 14:54

score 1 · Answer 3 · answered Aug 26 '12 at 14:40

No there is no syntactical construct for that because the +-operator is per definition not commutative in c++. That means you have to define second version, however it is reasonable to call the first version with swapped parameters in the implementation.

score 0 · Answer 4 · answered Aug 26 '12 at 14:51

You need either an implicit conversion or else a second operator definition, but it's completely possible to make the second definition reusable, so your code would look like this:

class Fraction : public commutative<Fraction>
{
  int num, den ;

  friend Fraction operator+ (int add_int, Fraction obj);
public:
   //member functions here
};
Fraction operator+ (int add_int, Fraction obj);

Let me know if you want sample code for the commutative<T> class template.

Thanks... I have it templatized. – Coding Mash Aug 26 '12 at 14:57 — Coding Mash, Aug 26 '12 at 14:57

Is it better to overload addition operator as non-member function?

4 Answers4