Using the C preprocessor to effectively rename variables

Question

I'm writing a few very tight loops and the outermost loop will run for over a month. It's my understanding that the less local variables a function has, the better the compiler can optimize it. In one of the loops, I need a few flags, only one of which is used at a time. If you were the proverbial homicidal maniac that knows where I live, would you rather have the flag named flag and used as such throughout or would you prefer something like

unsigned int flag;

while (condition) {

#define found_flag flag
  found_flag = 0;
  for (i = 0; i<n; i++) {
    if (found_condition) {
      found_flag = 1;
      break;
    }      
  }
  if (!found_flag) {
     /* not found action */
  }

/* other code leading up to the next loop with flag */
#define next_flag flag
  next_flag = 0;
/* ... /*  
}

This provides the benefit of allowing descriptive names for each flag without adding a new variable but seems a little unorthodox. I'm a new C programmer so I'm not sure what to do here.

when in doubt, measure (or look at the generated assembler). — msw
– msw, Commented Aug 27, 2010 at 5:00
and yes, horribly, painfully, bite you in the posterior unorthodox — msw
– msw, Commented Aug 27, 2010 at 5:01
You'd be saving around 4 bytes of space per flag variable, and that's if you discovered your compiler didn't optimise the space. — dreamlax
– dreamlax, Commented Aug 27, 2010 at 5:07
@dreamlax What I read was that this will make it more likely that the compiler just sticks everything in a register which is what I want but I can see that it's a bad idea. It says I have to wait a few minutes before I accept your answer but consider it done. — aaronasterling
– aaronasterling, Commented Aug 27, 2010 at 5:09
@aaronasterling: If the compiler can see that the usage of each flag variable never overlaps and is used in a manner that a register would be most suitable for, then chances are it will use a register. A lot of effort goes into a compiler's optimiser. Also, you're doing pretty well for being new to C. I remember thinking the same question back when I was beginning C. — dreamlax
– dreamlax, Commented Aug 27, 2010 at 5:15

dreamlax · Accepted Answer · 2010-08-27 04:58:13Z

14

Don't bother doing this, just use a new variable for each flag. The compiler will be able to determine where each one is first and last used and optimise the actual amount of space used accordingly. If none of the usage of the flag variables overlap, then the compiler may end up using the same space for all flag variables anyway.

Code for readability first and foremost.

answered Aug 27, 2010 at 4:58

dreamlax

95.7k31 gold badges166 silver badges211 bronze badges

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

1 Comment

Ken Clement Over a year ago

From @dreamiax 's lips (or rather keyboard in this case) to God's ear, stronger truths were never uttered. Please don't do this!

Community · Accepted Answer · 2017-05-23 12:23:24Z

3

I completely agree with dreamlax: the compiler will be smart enough for you to ignore this issue entirely, but I'd like to mention that you neglected a third option, which is rather more readable:

while (something) {
  /* setup per-loop preconditions */
  {
    int flag1;
    while (anotherthing) {
      /* ... */
    }
    /* deal with flag found or not-found here */
  }

  /* possibly some other preconditions */
  {
    int flag2;
    while (stillanotherthing) {
      /* ... */
    }
  }
}

which would tell a dumb compiler explicitly when you are done with each flag. Note that you will need to take care about where you declare variables that need to live beyond the flag-scope blocks.

edited May 23, 2017 at 12:23

CommunityBot

11 silver badge

answered Aug 27, 2010 at 5:13

dmckee --- ex-moderator kitten

102k25 gold badges147 silver badges238 bronze badges

3 Comments

dreamlax Over a year ago

Explicit scoping has become less popular now that C allows mixed declarations and code, but I still find myself using it every now and then.

starblue Over a year ago

You only need to do this in C89, not in C99 or C++ where you can declare a variable in the middle of blocks.

dmckee --- ex-moderator kitten Over a year ago

@starblue: the point (if aaron needed it on account of a really dumb compiler or something) would be to tell the compiler where you are done with a variable (i.e. when it goes out of scope) which is not something that the c99 mid-block declarations help with. As dreamlax said, the use of explicit scoping to declare variable in mid-block is consigned to the old standard, but they still have their uses.

hotpaw2 · Accepted Answer · 2010-08-27 05:19:15Z

3

Your trick would only be useful on very old, very simple, or buggy compilers that aren't capable of correct register (re)allocation and scheduling (sometimes, that's what one is stuck with for various or ancient embedded processors). gcc, and most modern compilers, when optimizations are turned on, would reallocate any register or local memory resources used for local variables until they are almost hard to find when debugging at the machine code level. So you might as well make your code readable and not spend brain power on this type of premature optimization.

answered Aug 27, 2010 at 5:19

hotpaw2

70.8k15 gold badges96 silver badges156 bronze badges

Collectives™ on Stack Overflow

Using the C preprocessor to effectively rename variables

3 Answers 3

1 Comment

3 Comments

Comments

Your Answer

Hot Network Questions

Collectives™ on Stack Overflow

3 Answers 3

1 Comment

3 Comments

Comments

Your Answer

Sign up or log in

Post as a guest

Related