Are #defines evil?

[daz001]

I tried to compile a class with:
static const int ERROR = 0;

seems harmless enough, but I get an error:
error C2059: syntax error : 'constant'

on digging deeper, I see the following definition in :
c:\program files\microsoft visual studio 8\vc\platformsdk\include\wingdi.h

#define ERROR 0

If I rename my static data member to MY_ERROR, then the problem goes away?

Am I to conclude that all the # defines in the various windows headers have polluted the namespace? What gives?

[ahoodin]

Well possibly your compiler can't handle it, this issue has been verified with MSVC. So do this:

In your class header:

static const int ERROR;

Then in the top of your class implementation file or source file:

const int MyClass::ERROR=0;

[laserlight]

Am I to conclude that all the # defines in the various windows headers have polluted the namespace?

Macros do not obey the rules of scope.

You might want to read Stroustrup's FAQ on So, what's wrong with using macros? Unfortunately, it will not help you in this case, except maybe to suggest that you use a different naming convention for non-macro names.

Well possibly your compiler can't handle it, this issue has been verified with MSVC.

The version of MSVC is recent enough that initialising integral class constants in the class definition should not pose a problem. It looks like the problem is clearly due to a conflict with a macro name, in which case your solution would also not work.

[daz001]

Thanks,

I think it will be a good idea to never use tokens with all caps. Maybe "Error" would have been much better here.

[laserlight]

I think it will be a good idea to never use tokens with all caps.

Except when it is a macro name, and if you use a header inclusion guard you would certainly be defining a macro.

[Doron Moraz]

As Meyers wrote:

"Given the availability of consts, enums and inlines, your need for the preprocessor (especially #define) is reduced. bit it's not eliminated.
#include remains essential, and #ifdef/#ifndef continue to play important roles in controlling compilation. It's not yet time to retire the pre-processor, but you should definitely give it long and frequent vacations."

Doron

[JohnW@Wessex]

Are #defines evil?

Of course! I blame them for the current world economic turmoil, as well as the basis of many conspiracy theories.

[laserlight]

ahoodin asked why I wrote that his/her solution would not work. My reasoning is that if a header is included such that this macro definition is in effect:

#define ERROR 0

Then the declaration:

static const int ERROR;

would become:

static const int 0;

after preprocessing, and this would result in a compile error. This is pretty much the problem that daz001 was asking about.

[ahoodin]

No, I didn't ask. Must have been a miss-communication. Good answers though Laserlight.

Are #defines evil?

I dunno about evil, maybe naughty. They are naughty bits left over from C.

The worst part of #defines are that mostly they elude the compiler. The doesn't complain when
your setting a 32 bit variable to a 16 bit macro definition. I have seen programs silently die for example
when a 32 bit coordinate is requested from a scrolling control with a 16 bit limit.

#defines are pretty much just a text replacement, and macros can break your code in funny ways.

Also the preprocessor step occurs before your compilation process, so the compiler doesn't have
an opportunity to spit errors at you.

[Kheun]

To quick work around is to use #undef to undefine the macro in your cpp file. As long as the const is being defined as private in the cpp file, it shouldn't conflict with the rest of the code.