Keeping variables inside the scope of the loop where they are used

Question

I am reading Stroustrup's book and he recommends we keep variables used inside loops, only inside the scope of the loop. This is easy to do for one variable but for more variables there are more options to do it, but I am not sure is it worth it. Do you guys bother with this at all?

For example:

for (double d; is >> d;) {}

it is better to keep the variable d inside the loop scope rather than do this:

double d;
for (;is >> d;) {}

well, this is very opinion based, but I struggle to see why you would trust anyone here more than the mighty Stroustrup. I certainly follow this advice most of the time. — RichardPlunkett, Dec 26 '13 at 13:24
@RichardPlunkett: I can't see any opinions here. Making variables as local as possible is *per se* always good. If you can't do it (because you need the variable later or because of multiple variable wit different types), they you can't (no choice, no opinion). It might lead to too long initialization clauses, which is ugly and then different people would weight it differently. But this weighting is a different question. — maaartinus, Feb 14 '14 at 23:24

6502 · Accepted Answer · 2013-12-26T13:38:56.213

In general the smaller the scope is, the better.

There are three main reasons for this rule:

Who is reading the code is not distracted trying to understand where the life of the variable will end. Using local variables you can skip over sections of code being sure that in the part skipped nothing you are interested in happened. If instead you use a variable that is not local and reuse it later who is reading must check if any of the code in the middle is using the variable.
When maintaining the program you're free to change the code without worrying that code that follows it may stop working because was dependent on a variable. Suppose you've a loop and is using a variable that is not local and then you change that loop with a call to a function... the risk is that code following the original loop was depending on the value of the index.
Compilers today are quite smart, but sometimes it's confusing even for them if you keep long lifespans for variables. As a result register allocation may suffer from this and the compiled code can be less efficient.

If in a function you want to do a step of processing that needs some locals but this step depends on a lot of context and it's not easy to factor it out in a function (because you'd need to pass a lot of parameters) then just open a block for the locals:

... code before ...
{
   int local1, local2;
   ... processing here ...
}
... code after ...

This is very readable and allows maintaining the smallest possible scope.

score 1 · Answer 2 · answered Dec 26 '13 at 13:23

Keeping variables in the smallest possible scope is worthwhile, and can avoid problems with name collisions, shadowing, etc. But it's hard to give complete general guidance because code like your example:

for (double d; is >> d;)

Is not likely to be found in the wild. I have done something like this though:

for (string s; getline(is, s); )

And there's a version using "if" which is handy:

if (MyThing* t = dynamic_cast<MyThing*>(o))

That gives you access to t within the conditional's body, but not outside, which is sort of nice because outside it would be null anyway.

score 0 · Answer 3 · answered Dec 26 '13 at 13:22

0

generally you should always keep those variables in the scope of the loop.

answered Dec 26 '13 at 13:22

cageman

315
2
10

no matter how ugly it is to implement that? :( – user3111311 Dec 26 '13 at 13:25
Beauty lies in the eyes of the beholder – Suvarna Pattayil Dec 26 '13 at 13:29
readability is a reason to move them in front of the for loop. I hate people who put in really long initialization clauses in their loops. But I hate people polluting namespaces needlessly too, so sometimes my anger is unavoidable. – RichardPlunkett Dec 26 '13 at 13:33
1

@RichardPlunkett Try listening to death metal then. – user3111311 Dec 26 '13 at 13:36

score 0 · Answer 4 · answered Dec 26 '13 at 13:26

0

well, this is very opinion based, but I struggle to see why you would trust anyone here more than the mighty Stroustrup. I certainly follow this advice most of the time.

If you put it in outside, like the second option, it means you can access the value after the loop. Thus sometimes you need to do that.

Since later access is the advantage of outside declaration, it is also slightly implied that you intend to this this when you use outside declaration, implying things that aren't true is bad, so if you dont use the values later, dont declare them outside.

answered Dec 26 '13 at 13:26

RichardPlunkett

2,958
11
14

So it is just matter of need and style? One way or the other is not better in terms of performance? – user3111311 Dec 26 '13 at 13:27
limiting scope can help the compiler make better guesses when optimizing, but there is no other upside for performance, and even that one is unlikely to have effect. – RichardPlunkett Dec 26 '13 at 13:29
Locally scoped means you get destroyed earlier too, which again can make a few tiny changes to performance, but not enough to care about normally. – RichardPlunkett Dec 26 '13 at 13:31

score 0 · Answer 5 · answered Dec 26 '13 at 13:27

There are a few points to this:

It improves the compilers ability to optimise, because variables that no longer are in scope doesn't need to be considered. However, modern compilers are pretty good at "following" variables and understanding when things can be optimised and when not from this.
The reader of the code doesn't need to worry about "is this variable used in the following lines after the loop".
The construction/desctruction of variables when they are used inside a loop may create extra overhead if the loop isn't entered. Likewise for the case of if/else statements, of course.

I think point #2 is the most important - if I can see how the variable is used for its lifetime in a short piece of code, that is really helpful.

score 0 · Answer 6 · answered Dec 26 '13 at 13:30

0

If you want to use the loop variable outside the loop then define it outside otherwise keep those variables in the scope of the loop.

answered Dec 26 '13 at 13:30

user3134167

275
1
2
10

Yes that is good principle, the problem is making it happen can be ugly, especially initializing more variables of different type. You can't do it in the for loop. – user3111311 Dec 26 '13 at 13:31

score 0 · Answer 7 · answered Dec 26 '13 at 18:33

An interesting idiom I've used, especially in the context of iterators, is the usage of the comma operator for multiple values that need to be bound into a for scope:

for(vector<int>::iterator iter = foo.begin(), end = foo.end(); iter != end; ++iter)

I used this technique to avoid repeating the type definition, but it is equally well served in allowing scope capture that is much prettier.

With C++11 auto semantics, this becomes even prettier:

for(auto iter = foo.begin(), end = foo.end(); iter != end; ++iter)

As for performance, this allow even the simplest of compilers (for example, tccp) to correctly optimize variable reuse (important in embedded systems or when no optimizations are on).

Keeping variables inside the scope of the loop where they are used

7 Answers7