Should I use #define, enum or const?

Question

In a C++ project I'm working on, I have a flag kind of value which can have four values. Those four flags can be combined. Flags describe the records in database and can be: - new record - deleted record - modified record - existing record Now, for each record I wish to keep this attribute, so I could use an enum: ``` enum { xNew, xDeleted, xModified, xExisting } ``` However, in other places in code, I need to select which records are to be visible to the user, so I'd like to be able to pass that as a single parameter, like: ``` showRecords(xNew | xDeleted); ``` So, it seems I have three possible appoaches: ``` #define X_NEW 0x01 #define X_DELETED 0x02 #define X_MODIFIED 0x04 #define X_EXISTING 0x08 ``` or ``` typedef enum { xNew = 1, xDeleted, xModified = 4, xExisting = 8 } RecordType; ``` or ``` namespace RecordType { static const uint8 xNew = 1; static const uint8 xDeleted = 2; static const uint8 xModified = 4; static const uint8 xExisting = 8; } ``` Space requirements are importan…

Accepted Answer

Combine the strategies to reduce the disadvantages of a single approach. I work in embedded systems so the following solution is based on the fact that integer and bitwise operators are fast, low memory & low in flash usage.

Place the enum in a namespace to prevent the constants from polluting the global namespace.

```
namespace RecordType {
```

An enum declares and defines a compile time checked typed. Always use compile time type checking to make sure arguments and variables are given the correct type. There is no need for the typedef in C++.

```
enum TRecordType { xNew = 1, xDeleted = 2, xModified = 4, xExisting = 8,
```

Create another member for an invalid state. This can be useful as error code; for example, when you want to return the state but the I/O operation fails. It is also useful for debugging; use it in initialisation lists and destructors to know if the variable's value should be used.

```
xInvalid = 16 };
```

Consider that you have two purposes for this type. To track the current state of a record and to create a mask to select records in certain states. Create an inline function to test if the value of the type is valid for your purpose; as a state marker vs a state mask. This will catch bugs as the `typedef` is just an `int` and a value such as `0xDEADBEEF` may be in your variable through uninitialised or mispointed variables.

```
inline bool IsValidState( TRecordType v) {
    switch(v) { case xNew: case xDeleted: case xModified: case xExisting: return true; }
    return false;
}

inline bool IsValidMask( TRecordType v) {
    return v >= xNew  && v < xInvalid ;
}
```

Add a `using` directive if you want to use the type often.

```
using RecordType ::TRecordType ;
```

The value checking functions are useful in asserts to trap bad values as soon as they are used. The quicker you catch a bug when running, the less damage it can do.

Here are some examples to put it all together.

```
void showRecords(TRecordType mask) {
    assert(RecordType::IsValidMask(mask));
    // do stuff;
}

void wombleRecord(TRecord rec, TRecordType state) {
    assert(RecordType::IsValidState(state));
    if (RecordType ::xNew) {
    // ...
} in runtime

TRecordType updateRecord(TRecord rec, TRecordType newstate) {
    assert(RecordType::IsValidState(newstate));
    //...
    if (! access_was_successful) return RecordType ::xInvalid;
    return newstate;
}
```

The only way to ensure correct value safety is to use a dedicated class with operator overloads and that is left as an exercise for another reader.

Should I use #define, enum or const?

Solution

Problem

Related problems