brown@ncratl.Atlanta.NCR.COM (Kyle Brown) (09/12/89)
Hi Folks. Here's a little question that's come up as I try to put together a style guide for C++ programming. In standard C (and other block-structured languages) it's common to declare all variables in a block at the beginning of your program. However, in C++ it is often useful to declare some variables close to their first point of use. (See Stroustroup 1986 for a discussion) For example, some object constructors have parameters that may not be defined at the beginning of a block, etc. Has anybody developed any style rules for this? I'm especially worried about the tradeoff of readability for optimization. (This becomes a real issue in loop indices) Any pointers to information on general C++ style (other than Stroustroup and Wiener and Pinson, which I have) would be helpful.
jima@hplsla.HP.COM (Jim Adcock) (09/14/89)
> Has anybody developed any style rules for this? I'm especially worried > about the tradeoff of readability for optimization. (This becomes a real > issue in loop indices) There shouldn't be any issue of optimization no matter where one declares one's variables using any modern optimizing compiler. The optimizing compiler will analyze what scope of the code your variable is actually used in, and will free that variable's register for other usage elsewhere. So feel free to do whatever style of declaration makes your code most readable. --- If a variable is widely used throughout a procedure, declare and initialize it at the start of a procedure. If a variable is only used locally in a procedure, perhaps only in a couple lines of code, then declare and initialize it where first used. But *don't* make the mistake of introducing a variable in the middle of your code, then using it again later. Of course, one isn't tempted to do this is one keeps one's routines small. Other no-nos: don't use the same variable name more than once in a routine with differing meanings, or with differing types. As the following example demonstrates, for-loop scope [for historical reasons] is not what one would wish when declaring dummy loop variables. You could handle this by adding curly braces to make a local scope, but this is not a common style. Maybe one should continue in the C style of declaring standard dummy loop variables at the start of a routine? #include <stdio.h> void doSmethingWith(int i) {printf("%d\n",i);} void aLoopyRoutine() { for (int i=0; i<10; ++i) doSomethingWith(i); // more code for (int i=0; i<10; ++i) doSomethingWith(i*i); //error: two declarations of i } void aLoopyRoutine2() { {for (int i=0; i<10; ++i) doSomethingWith(i);} // curly braces make i local // more code {for (int i=0; i<10; ++i) doSomethingWith(i*i);} //okay; but not common style } void aLoopyRoutine3() { int i; //maybe just declare common dummy loop variables at start? for (i=0; i<10; ++i) doSomethingWith(i); // more code for (i=0; i<10; ++i) doSomethingWith(i*i); } void main() { aLoopyRoutine(); aLoopyRoutine2(); aLoopyRoutine3(); }
bright@Data-IO.COM (Walter Bright) (09/14/89)
In article <953@ncratl.Atlanta.NCR.COM> brown@ncratl.Atlanta.NCR.COM (Kyle Brown) writes:
<In standard C (and other block-structured
<languages) it's common to declare all variables in a block at the beginning
<of your program. However, in C++ it is often useful to declare some
<variables close to their first point of use.
<Has anybody developed any style rules for this?
Declare variables in the innermost set of {} that you can. This improves
both readability and optimizability (for compilers that can't do live
range analysis).
The idea is to reduce the scope of the variable to a minimum. Readability
is enhanced because it reduces the number of lines of code you have to scan
to figure out all the uses of a variable. Reducing the scope improves the
possibility that the optimizer could share its storage with another variable
that has a non-intersecting scope (which can result in more variables going
into registers!).baud@eedsp.gatech.edu (Kurt Baudendistel) (09/15/89)
In article <6590251@hplsla.HP.COM> jima@hplsla.HP.COM (Jim Adcock) writes: >There shouldn't be any issue of optimization no matter where one declares >one's variables using any modern optimizing compiler. Be careful when making statements like this! ;-) If you are talking about strictly automatics (locals), this is true, but not if you are comparing automatics and external (global) variables. Automatics can be much more easily and effectively optimized than externals; witness the code generated by the GNU C/C++ compiler. kurt -- Kurt Baudendistel --- GRA Georgia Tech, School of Electrical Engineering, Atlanta, GA 30332 internet: baud@eedsp.gatech.edu uucp: gatech!gt-eedsp!baud
jima@hplsla.HP.COM (Jim Adcock) (09/19/89)
> >There shouldn't be any issue of optimization no matter where one declares > >one's variables using any modern optimizing compiler. > > Be careful when making statements like this! ;-) If you are talking about > strictly automatics (locals), this is true, but not if you are comparing > automatics and external (global) variables. Automatics can be much more > easily and effectively optimized than externals; witness the code generated > by the GNU C/C++ compiler. > > kurt Sorry, I assumed that since globals are typically bad programming practice, and typically less efficient than automatics, that people would not *think* I was referring to them. Don't use globals unless forced to -- and with static class members, why would you be forced to?