Thread: Enums Vs symbolic variables.

I've always used symbolic variables, typically to remove magic numbers, but also to make my code more readable. As you're aware some of the best books in C are really old so compilers have changed a lot.

Today I stumbled across a post that said it is best to use enums rather than symbolic variables. I, as a general rule of thumb, avoid switch statements, in Java I only really used enums when I had no choice but to use a switch.

So, to get to the point here. I'll supply some code (the code is just something I wrote for some Genuino fun, but I use symbolic variables to make it easier to change things and little more human-readable.

Code:

/* digial pins */
#define RED_LED_ONE 4
#define RED_LED_TWO 5
#define GREEN_LED 3
#define CURCUIT 2

/* timer for delay() */
#define TIMER 500

/* function prototype */
void flashOnStart(void);

/*  hate these globals. Might put 
 *  these in the loop function and make them
 *  static (dunno if that will work, guess i'll find out). */
int switchState = 0;
int flash = 0;

void setup() {
  // put your setup code here, to run once:
  pinMode(GREEN_LED, OUTPUT);
  pinMode(RED_LED_ONE, OUTPUT);
  pinMode(RED_LED_TWO, OUTPUT);
  pinMode(CURCUIT, INPUT);
}

void loop() {
  // put your main code here, to run repeatedly:
  switchState = digitalRead(CURCUIT);

  for (;flash < 7; flash++)
    flashOnStart();
    
  if (switchState == LOW)
  {
    /* switch has not been pressed. */
    
    // power green LED
    digitalWrite(GREEN_LED, HIGH);
    // keep both red LEDs powered down.
    digitalWrite(RED_LED_TWO, LOW);
    delay(TIMER);
    digitalWrite(RED_LED_ONE, LOW); 
  }
  // 
  else
  {
    /* switch has been/is currently pressed. */

    // turn off green LED.
    digitalWrite(GREEN_LED, LOW);
    // power both red LEDS up.
    digitalWrite(RED_LED_ONE, HIGH);
    delay(TIMER);
    digitalWrite(RED_LED_TWO, HIGH);
  }
}

/* flash the green LED on and off */
void flashOnStart(void)
{
  if (digitalRead(GREEN_LED) == HIGH)
    digitalWrite(GREEN_LED, LOW);
  else
    digitalWrite(GREEN_LED, HIGH);
    
  delay(TIMER); 
}

How would I go about changing those symbolic variables to an enum?

Originally Posted by Lawson

Enums Vs symbolic variables.

The usual term used for the latter would be "macro" or more specifically "object-like macro".

Originally Posted by Lawson

Today I stumbled across a post that said it is best to use enums rather than symbolic variables.

One reason why I would not call macros "symbolic variables" has to do with an advantage of enums such that you read that recommendation: after macro replacement, the symbolic name is gone, hence you may find that when you observe your program in a debugger, the symbolic names associated with enums remain, but you only see the replaced value with macros. This is an advantage in favour of the use of enums.

Originally Posted by Lawson

How would I go about changing those symbolic variables to an enum?

The thing is though, enums don't exist solely for named constants to be defined. Rather, they (rather loosely) form a new type that is intended to have only those enumerated values. Consequently, it is most appropriate to create an enum to enumerate (duh) some list of related constants, especially where the actual values matter less than the fact that they are unique (hence the behaviour of subsequently declared values being incremented automatically). Of course, this does not mean that it is inappropriate to specify particular values, or that we cannot have duplicate values, but if we do this, then we need to take extra care that we really do have an "enumeration" and not merely a disparate list of named constants.

In your case, I would probably have an enum for the digital pins, e.g.,

Code:

enum DigitalPin {
    CURCUIT = 2,
    GREEN_LED,
    RED_LED_ONE,
    RED_LED_TWO
};

But I would keep TIMER as a macro since it is a separate constant. Or, seeing that you do not use TIMER to specify the size of an array, perhaps it would be appropriate to write:

Code:

const int TIMER = 500;

If you really do want TIMER to be an enumerator, then it should be in an enumeration separate from the digital pins enumeration.

Originally Posted by Lawson

Probably getting my terminology all mixed up again. I thought it was only a macro if you did something like:

Code:

#define ADD(x, y) (x) + (y)

That's also a macro: a function-style macro.

Originally Posted by Lawson

And would that also mean i'd have to do one of the following:

Well, if you don't need those variables, you could write:

Code:

enum pins { blue = 5, red = 6, yellow = 7 };

int main() {

    printf("%d %d %d\n", blue, red, yellow);

    return 0;
}

Originally Posted by Lawson

macros are taken care of during the 'prepossessing' stage.. not sure about enums, is there a performance hit/gain using macros over enums or vice versa?

Enums are not specified by preprocessor directives, so they are not replaced during preprocessing. No, there should be no performance difference.

An enumeration is not a structure. Rather, an enumeration specifies an enumeration type and the members of the enumeration, i.e., the enumerators. These enumerators are constants, so they can be used as constants.