Let's say I have something like this :
enum CardColor { HEARTS, DIAMONDS, CLUBS, SPADES};
CardColor MyColor = static_cast<CardColor>(100);
Is there a (simple) way to detect, either at compile-time or at runtime, that the value of MyColor doesn't correspond to any enumerated value ?
And more generally, if the enum values are not following each other, for instance :
enum CardColor { HEARTS = 0, DIAMONDS, CLUBS = 4, SPADES};
CashCow presents a decent answer to this question: it's certainly straightforward to write a custom function to perform a checked cast.
Unfortunately, it's also a lot of work and you must make sure to keep it synchronized with the enumeration so that the list of enumerators in the enumeration definition is the same as the list of enumerators in the checked cast function. You also have to write one of these for each enumeration to which you want to be able to perform a checked cast.
Instead of doing all this manual work, we can automate generation of all of this code using the preprocessor (with a little help from the Boost Preprocessor library). Here is a macro that generates an enumeration definition along with a checked_enum_cast function. It's probably a bit scary looking (code generation macros are often horrible to look upon), but it's an extremely useful technique to become familiar with.
#include <stdexcept>
#include <boost/preprocessor.hpp>
// Internal helper to provide partial specialization for checked_enum_cast
template <typename Target, typename Source>
struct checked_enum_cast_impl;
// Exception thrown by checked_enum_cast on cast failure
struct invalid_enum_cast : std::out_of_range
{
invalid_enum_cast(const char* s)
: std::out_of_range(s) { }
};
// Checked cast function
template <typename Target, typename Source>
Target checked_enum_cast(Source s)
{
return checked_enum_cast_impl<Target, Source>::do_cast(s);
}
// Internal helper to help declare case labels in the checked cast function
#define X_DEFINE_SAFE_CAST_CASE(r, data, elem) case elem:
// Macro to define an enum with a checked cast function. name is the name of
// the enumeration to be defined and enumerators is the preprocessing sequence
// of enumerators to be defined. See the usage example below.
#define DEFINE_SAFE_CAST_ENUM(name, enumerators) \
enum name \
{ \
BOOST_PP_SEQ_ENUM(enumerators) \
}; \
\
template <typename Source> \
struct checked_enum_cast_impl<name, Source> \
{ \
static name do_cast(Source s) \
{ \
switch (s) \
{ \
BOOST_PP_SEQ_FOR_EACH(X_DEFINE_SAFE_CAST_CASE, 0, enumerators) \
return static_cast<name>(s); \
default: \
throw invalid_enum_cast(BOOST_PP_STRINGIZE(name)); \
} \
return name(); \
} \
};
Here is how you would use that with your CardColor example:
DEFINE_SAFE_CAST_ENUM(CardColor, (HEARTS) (CLUBS) (SPADES) (DIAMONDS))
int main()
{
checked_enum_cast<CardColor>(1); // ok
checked_enum_cast<CardColor>(400); // o noez! an exception!
}
The first line replaces your enum CardColor ... definition; it defines the enumeration and provides a specialization that allows you to use checked_enum_cast to cast integers to CardColor.
This may look like a lot of hassle just to get a checked cast function for your enums, but this technique is very useful and extensible. You can add functions that do all sorts of things. For example, I have one that generates functions to convert enumerated types to and from string representations and functions that perform several other conversions and checks that I use for most of my enumerations.
Remember, you have to write and debug that big, ugly macro just once, then you can use it everywhere.
Simplest run-time solution would be to not use static_cast but use a function that does the check for you. If you put your enum inside a class you can do that through the class. Something like:
class CardCheck
{
public:
enum CardColor { HEARTS, DIAMONDS, CLUBS, SPADES };
explicit CardCheck( int x ) : c( static_cast< CardColor >( x ) )
{
switch( c )
{
case HEARTS: case DIAMONDS: case CLUBS: case SPADES:
break;
default:
// assert or throw
}
}
CardColor get() const
{
return c;
}
private:
CardColor c;
};
clang have support for dynamic overflow checks. See -fsanitize=enum switch. A program compiled with this switch will signal enum assignment errors through stderr output. This will allow you to do debug tests. It is not suitable to test suspicious input in official build.
It is common to have an additional element at the end of the enum indicating the number of items in it. You can use that value to check at runtime if the value is valid:
enum CardColor { HEARTS, DIAMONDS, CLUBS, SPADES, CARDS_COUNT};
CardColor MyColor = static_cast<CardColor>(100);
if (MyColor >= CARDS_COUNT) {
/* Invalid value */
}
At the beginning - it's bad idea to do this.
But if you want, I suggest to hardcode integer values of enumeration:
enum CardColor { HEARTS = 10, DIAMONDS = 11, CLUBS = 12, SPADES = 13};
Then overload assigment operator:
CardColor operator = (int value)
{
switch (value)
{
case 10:
return HEARTS;
// case for other values
default:
// throw an exception or something
}
}
Enumeration values may overlap or have holes; also, actual variables can be assigned zero, any value from the set or the bitwise OR of allowed values. So:
enum suites { hearts, diamonds, clubs, spades };
allows the values 0, 1, 2, 3;
enum suites { hearts = 1 << 0, diamonds = 1 << 1, clubs = 1 << 2, spades = 1 << 4 };
allows any value from 0 to 15.
If you use an enum to define bit values, it is usually a good idea to define (binary) operator&, operator|, operator&= and operator|=. If you don't do that, you will need an explicit cast whenever a value that is not in the set is generated, so the places where this happens can be easily spotted.
There are compilers that can warn if a number outside the allowed range is assigned, or if not either none, the first or all names have initializers attached to them (this is a violation of MISRA-C rules).
