#define or enum? [duplicate]

Answer 1

I prefer enum. They are more compact and are 'safer'. You can also imply order in an enum, which might be helpful in a state machine. #defines should be avoided if possible, since they will overwrite all occurrences in source, which can lead to some unintended actions which are difficult to debug.

Answer 2

You can use whatever you want and like.

Still as everyone is saying I would also like add up me as voting for Enums.

Enums should always be preferred if you are using related data as in case of a State Machine, you can define order in enums also that will help in implementing the State Machine.

Further enums will keep your program safe as all enums will be of its type only so they will avoid any possible confusions too.

#define should not be used in case of a state machine or related data. Anyway thats my suggestion, but there is no hard and fast rule.

Also I would like to add up one more point that enums will add more readability and understandability to your code if used in future or or if read by someone else. It is an important point when you are having a very large program and there are a lot of #defines in the program other than you are using for your State Machine.

Answer 3

There's no definitive answer. enum offers you scoping and automatic value assignment, but does not give any control over the constant type (always signed int). #define ignores scoping, but allows you to use better typing facilities: lets you choose the constant type (either by using suffixes or by including an explicit cast into the definition).

So, choose for yourself what is more important to you. For a state machine, enum might be a better choice, unless you have a good reason to control the type.

Answer 4

If enum is supported by your compiler, then that would be preferred. Failing that, by all means, use #define. All C++ compilers and modern C compilers should support enum, but older compilers (particularly ones targeting embedded platforms) may not support enum.

If you must use #define make sure to define your constants with parentheses, to avoid preprocessor errors:

#define RED_STATE    (1)
#define YELLOW_STATE (2)
#define GREEN_STATE  (3)

Answer 5

You can do this trick to make compiler check the type of #define value.

#define VALUE_NAME ((TYPE_NAME) 12)

However the real problem of #define is it can be redefined in application code. (Of course compiler will warn you about it.)

Answer 6

#define directives can have lots of unintended consequences and don't follow common scoping rules. Use enums when you have related data.

More information: http://www.embedded.com/columns/programmingpointers/9900402?_requestid=341945 [C++ material, but still marginally relevant]