Storing value before return in a variable

Question

Here is a fragment of code:

bool EqualsA(const Foo& a, const Foo& b) { return a == b; } bool EqualsB(const Foo& a, const Foo& b) { const bool result = a == b; return result; } int MethodA() { return GetValue() * GetOtherValue(); } int MethodB() { const int result = GetValue() * GetOtherValue(); return result; }

I wanted to know if there is any difference in returning values in these two different ways (instant return or store result in a variable). I think that storing is better for debugging but is there any performance loss (I don't think there is) or any other pros and cons for using one of those.

Seems pretty useless to store the result without doing anything with it. — Qaz
– Qaz, Commented Feb 25, 2013 at 23:00

Community · Accepted Answer · 2017-05-23 12:27:14Z

4

The compiler is free to optimize away the local variable so the performance is going to be the same.

In a lot of code analysis tools this is marked as a code smell and I would tend to agree. Debuggers can be made to see the return value on the stack so the local variable doesn't buy anything.

edited May 23, 2017 at 12:27

CommunityBot

11 silver badge

answered Feb 25, 2013 at 23:02

Andrew White

53.6k20 gold badges116 silver badges138 bronze badges

Sign up to request clarification or add additional context in comments.

2 Comments

Mooing Duck Over a year ago

I find it easier to debug when I store the temporaries in variables, I can just break on a line and immediately see all the "temporaries". Otherwise, I have to stop the line before, and step in and out to view all the temporaries one at a time

Loki Astari Over a year ago

I like the temps for debugging. But result = a == b; is overkill for me. It all depends on the context and how much effort it would involve.

Andy Prowl · Accepted Answer · 2013-02-25 23:02:43Z

Under the reasonable assumption that the value returned by the selected overload of operator == for objects of type Foo is of type bool, a decent compiler will optimize your temporary store away when heavy optimization options are used, so as for performance, it does not matter.

My advice is to choose the form that makes your code more readable or more convenient to maintain or debug for you.

Joseph Mansfield · Accepted Answer · 2013-02-25 23:08:43Z

There will almost certainly be no difference. The compiler is allowed to do whatever it likes to your code as long as the program behaves as-if it were as you wrote it. So any nice compiler will get rid of the pointless initializations.

However, it's possible for there to be a situation it can't make this initialization disappear. If, for example, an operator* overload used for GetValue() * GetOtherValue() returns a class type result by const reference, the constructor of that class type might have some side effects. If it does, the compiler can't get rid of the initialization because it changes the observable behaviour of the program.

But why would that not also be the case if the operator* returned by value? Then this would be a candidate for copy elision, and the compiler could get rid of the construction regardless of whether it had side effects or not.

Collectives™ on Stack Overflow

Storing value before return in a variable

3 Answers 3

2 Comments

Comments

Comments

Linked

Hot Network Questions

Collectives™ on Stack Overflow

3 Answers 3

2 Comments

Comments

Comments

Linked

Related