With those enums you wont be able to use them as bitflags. You can''t do that because when it comes time to pass those to a function the function will expect a single TEXTFLAGS enum. If you want to get around it and your compiler supports nameless enums then do

enum
{
TF_BOLD = 0x0001,
TF_ITALIC = 0x0002,
TF_LEFTJUSTIFY = 0x0004,
...etc
}

then your function can take any type that works with bitflags, char, int, whatever.

------------
- outRider -

#defines in header files should generally be avoided. That is because every file that includes a header with a certain #defined constant is not allowed to redefine that constant. And it is not even allowed to use the defined identifier in another context because it will be replaced by the preprocessor. #defines are always global and they are independent from namespaces and scope.

So if you need to define a range of related constants, use an enumeration. If the enumeration is only used by a certain class, put it into the definition of that class and make it a local enumeration. This way, you prevent cluttering up the global namespace. If you need a single constant, unrelated to other constants, define it as a const variable, preferably inside a class definition.

If a range of constants should be used as flags as outRider pointed out, using an enumeration would be wrong. You could use #defines here, as the DirectX SDK headers do, but better yet use const declarations. And again, preferably inside a class definition or at least, a unique namespace. This way, nobody will ever have to worry when including your headers.

Source files (implementation files) are an entirely different topic. They will never be included anywhere, so feel free to clutter up the global namespace and go crazy with #defines - nobody will ever find out. As long as you can still maintain the code, it''s all right. But remember that consts and enums aren''t slower than #defines are - and they will be handled by the compiler, not by the preprocessor.

In general, constants should always be defined using the means provided by the language, not by the preprocessor. Macros are a different topic. They can really ease some tasks in implementation files and the are definitely not "evil" or anything.

Last but not least, if you really have to use #defined constants in a header file (I can''t see an urgent reason, though), make them as unique as possible. Think about using a common prefix as the DirectX SDK headers do.

That''s it. Happy coding.

quote:Original post by outRider
With those enums you wont be able to use them as bitflags. You can''t do that because when it comes time to pass those to a function the function will expect a single TEXTFLAGS enum. If you want to get around it and your compiler supports nameless enums then do

That''s funny... I use enum''s as bitflags no problem:





---- --- -- -
Blue programmer needs food badly. Blue programmer is about to die!

You're combining your enums within the definition, not passing them to the function straight. Doing it that way you'd have to pre-combine every combination a user might want... I sure as hell wouldn't want to do that for an enum of more than a couple of entries.




main.cpp(17) : error C2664: 'func' : cannot convert parameter 1 from 'const int' to 'enum Bitflags'
Conversion to enumeration type requires an explicit cast (static_cast, C-style cast or function-style cast)

You can do func((Bitflags)(bit1 | bit2)); but it's easier to just use an unnamed union.

------------
- outRider -

[edited by - outRider on August 13, 2002 1:16:08 AM]

Yeah, you can only use them as bitflags if you convert them to a built-in type like int.




[edited by - Origin on August 13, 2002 5:42:44 AM]