Question

Possible Duplicate:
static const vs #define

In C++, to define a constant to be used across the entire application, what is the usual practice?

#define WINDOWS_HEIGHT 1024

or

const int WINDOWS_HEIGHT = 1024;

Answer 1

Pros and cons to everything, depending on usage:

• enums
  • only possible for integer values
  • properly scoped / identifier clash issues handled nicely
  • strongly typed, but to a big-enough signed-or-unsigned int size over which you have no control (in C++03)
  • can’t take the address
  • stronger usage restraints (e.g. incrementing – template <typename T> void f(T t) { cout << ++t; } won’t compile)
  • each constant’s type taken from the enclosing enum, so template <typename T> void f(T) get a distinct instantiation when passed the same numeric value from different enums, all of which are distinct from any actual f(int) instantiation.
  • even with typeof, can’t expect numeric_limits to provide useful insight
  • the enum’s typename may appear in various places in RTTI, compiler messages etc. – possibly useful, possibly obfuscation
• consts
  • properly scoped / identifier clash issues handled nicely
  • strong, single, user-specified type
  • One Definition Rule complications
• defines
  • "global" scope / more prone to conflicting usages, which can produce hard-to-resolve compilation issues and unexpected run-time results rather than sane error messages; mitigating this requires:
    • long, obscure and/or centrally coordinated identifiers, and access to them can’t benefit from implicitly matching used/current/Koenig-looked-up namespace, namespace aliases etc.
    • use of all uppercase characters is generally required and reserved for preprocessor defines (an important guideline for enterprise scale preprocessor usage to remain manageable, and which 3rd party libraries can be expected to follow), observation of which implies migration of existing consts or enums to defines involves a change in capitalisation (and hence affects client code). (Personally, I capitalise the first letter of enums but not consts, so I’d be hit here anyway – maybe time to rethink that.)
  • more compile-time operations possible: string literal concatenation, stringification (taking size thereof)
    • downside is that given #define X "x" and some client usage ala "pre" X "post", you’re in trouble if you want or need to make X a runtime-changeable variable rather than a constant, whereas that transition is easier from a const char* or const std::string given they already force the user to incorporate concatenation operations.
  • can’t use sizeof directly on a defined numeric constant
  • untyped (GCC doesn’t warn if compared to unsigned)
  • some compiler/linker/debugger chains may not present the identifier, so you’ll be reduced to looking at "magic numbers" (strings, whatever…)
  • can’t take the address
  • the substituted value need not be legal (or discrete) in the context where the #define is created, as it’s evaluated at each point of use, so you can reference not-yet-declared objects, depend on "implementation" that needn’t be pre-included, create "constants" such as { 1, 2 } that can be used to initialise arrays, or #define MICROSECONDS *1E-6 etc. (definitely not recommending this!)
  • some special things like __FILE__ and __LINE__ can be incorporated into the macro substitution

As a general rule, I use consts and consider them the most professional option for general usage (though the others have a simplicity appealing to this old lazy programmer).