C++ Operator Overloading

Question

today my teacher showed me the following example:

CFraction operator*(const CFraction &a, const CFraction &b){ CFraction x; x.setNumerator(a.getNumerator()*b.getNumerator()); x.setDenominator(a.getDenominator()*b.getDenominator()); return x; } // ... void main(){ CFraction b1,b2(3,7),b3(5,8); b2=b1*3; b2=3*b1; }

He said that the above code would be working fine, but if you change the method to the following:

CFraction operator*(CFraction&,CFraction&);

it wouldn't work. Why is that?

Hope you can explain it to me.

Thanks in advance.

Try it and the compiler will tell you. Unless you are using MSVC, then it will keep working as an extension I believe. — Baum mit Augen
– Baum mit Augen ♦, Commented Mar 8, 2016 at 14:39
It's impossible to have an no const reference to a literal like 3 in your example for calculation of b2. — Garf365
– Garf365, Commented Mar 8, 2016 at 14:43

Slava · Accepted Answer · 2016-03-08 14:48:31Z

it wouldn't work. Why is that?

Let's look into your expression:

b2=b1*3;

is equal to:

b2=operator*(b1,3);

as second type is not type of CFraction it has to be converted to it ie:

b2=operator*(b1,CFraction(3));

CFraction(3) creates temporary object of type CFraction. Temporary is not lvalue so cannot be passed as lvalue reference - CFraction & and if you define your function with non const references (aka lvalue references) it would not work in this case.

Better use the proper term 'bind' (instead of vague 'passed as lvalue reference')

h0r53 · Accepted Answer · 2016-03-08 16:54:39Z

You are basically asking, "why should my arguments be const?"

There is actually a good reason for this in this scenario. In c++, whenever you have a function argument with a const reference, (amongst other things) it means you can pass in a literal as an argument into that function (assuming the capacity for a type conversion is available).

For example, if you don't use the const reference, you can still do something like:

 CFraction b1,b2(3,7),b3(5,8); b3=b1*b2;

In the prior example, you passed in (non constant) references to objects b1 and b2. That's alright because this expression makes sense. However, you could not do the following:

 CFraction b1,b2(3,7),b3(5,8); b3=b1*3;

Why? Because 3 is a literal. Whenever you don't include the const reference to CFraction, you cannot pass literals into that function as an argument. Using const reference enables you to pass in literal values.

@SergeyA It doesn't make the response incorrect. This is a supplementary answer to the information already provided by Slava.
@BarryTheHatchet, it makes it seems that if not for literal, it would work fine. For example, static int i; b3 = b1 * i; - this seems OK? No pesky literals in sight?
@SergeyA: Discussing A⇒C doesn't prohibit also B⇒C. Yes, this answer could be broader, but the other one does that quite well. This one is specific to the question. I think, in concert, they are both completely appropriate as-is.

Collectives™ on Stack Overflow

C++ Operator Overloading

2 Answers 2

1 Comment

8 Comments

Hot Network Questions

Collectives™ on Stack Overflow

2 Answers 2

1 Comment

8 Comments

Related