Why enumerator data type is used in c plus plus?

Answer 1

Enumerated data types are a set of user-defined constants called enumerators that provide context to a range of values. For instance, if you define the following constants:

static const int Monday=0;

static const int Tuesday=1;

// ...

static const int Sunday = 6;

static const int January=0;

static const int February=1;

// ...

static const int December=12;

Then there's nothing to prevent you from coding the following:

int var1 = January;

int var2 = Tuesday;

// ...

int var3 = var1 + var2;

What exactly does var3 represent? A month? A day? Or something else entirely? The problem is the compiler can't help you because you've not actually done anything wrong. As far as the compiler is concerned, all you've done is add two ints together to produce a third int. Whether it makes sense or not is another matter altogether.

Enumerations exist to prevent this sort of problem.

enum day { Monday, Tuesday, ..., Sunday };

enum month { January, February, ..., December };

month var1 = January;

day var2 = Tuesday;

// ...

int var3 = var1 + var2;

Now the compiler will tell you there is no suitable plus operator that accepts an l-value of month and an r-value of day.

Enumerators have an implied type of signed int, but you can also specify an alternative type, provided it is an intrinsically primitive integral type, such as int, char, or short, whether signed or unsigned. However, even when typed, you cannot use any operators upon them unless you specifically provide an operator overload to cater for them. Thus the following will not work:

for( day d=Monday; d<=Sunday; ++d )

// ...

Without a suitable operator overload for the prefix increment operator, you must use an explicit cast, such as follows:

for( int i=Monday; i<=Sunday; ++i )

{

day d = reinterpret_cast<day>(i);

// ...

}

Although you've got to work a bit harder to use enumerators, the point is that the additional work is required in order to prevent problems such as those highlighted at the start of this answer. Enumerators enlist the compiler to help you spot errors, forcing you to make a conscious decision whenever you want to override the compiler's help, but ultimately ensuring your code is as robust as possible.

Answer 2

An enum is essentially a collection of constants grouped under a common identifier. Unless otherwise specified, an enum value is of type int. If you do not specify any values for an enum member, the first member is assigned the value zero and all subsequent members increment from that point on (1, 2, 3, and so on). Thus if you define an enum as follows:

enum suit { hearts, spades, diamonds, clubs };

Then hearts will have the value 0, spades will have the value 1, diamonds 2, and clubs 3. This then makes it very easy to reference the equivalent strings in an array:

char* suit_str[4]={ "hearts", "spades", "diamonds", "clubs" };

Thus suit_str[hearts] would therefore reference the string "hearts".

If you define any member values, then the enumeration will start over from that point onward, incrementing for each subsequent member until another definition is encountered. You can also use existing definitions to produce bnew definition, thus making it possible to easily enumerate bit fields, simply by bit-shifting the previous enumeration to the left by 1 bit:

enum day{

sunday=1,

monday=sunday<<1,

tuesday=monday<<1,

wednesday=tuesday<<1,

thursday=wednesday<<1,

friday=thursday<<1,

saturday=friday<<1 };

In other words, sunday is 1, monday is 2, tuesday is 4, wednesday is 8, thursday is 16, and so on. You could then logically combine enumerations to produce new enumerations, such as weekend, workday, all_week and so on:

enum day {

sunday=1,

monday=sunday<<1,

tuesday=monday<<1,

wednesday=tuesday<<1,

thursday=wednesday<<1,

friday=thursday<<1,

saturday=friday<<1,

weekend=saturday | sunday,

workday=monday | tuesday | wednesday | thursday | friday,

all_week=weekend | workday };

By defining constants and grouping them in an enum in this way, you ensure your code is type safe because you can pass enums directly into functions:

void print_day( day dow )

{

switch( dow )

{

case( sunday ): std::cout<<"Sunday"; break;

case( monday ): std::cout<<"Monday"; break;

case( tuesday ): std::cout<<"Tuesday"; break;

case( wednesday ): std::cout<<"Wednesday"; break;

case( thursday ): std::cout<<"Thursday"; break;

case( friday ): std::cout<<"Friday"; break;

case( saturday ): std::cout<<"Saturday"; break;

case( weekend ): std::cout<<"Weekend"; break;

case( workday ): std::cout<<"Workday"; break; }

case( all_week ): std::cout<<"All Week"; break; }

}

}

You cannot call print_day(1) because the function expects an enum of type day, not a literal constant, you must call print_day(sunday) instead. However, this makes your code that much easier to read.

You can also assign enum values to other variables of the same type, just as you can with constants:

day someday = monday;

print_day(someday);

However, by default, you cannot perform compound assignments such as:

x|=tuesday;

x = thursday|friday;

This is because thursday|friday would return the underlying type, an int, not an enum, and you can't assign an int to an enum variable. While it is possible to overload these and other intrinsic operators to cast the underlying int to an enum, you must physically define all possible combinations of the enums in order to make the operation legitimate. That's 127 separate definitions in total! For most programmers that's simply too much effort and it's ultimately easier to simply treat the result as an int and cast to an enum only when it is appropriate to do so.

Although this appears to be a limitation of enumeration, it is actually a good thing as it narrows the scope of your variables, and adds a level of consistency and robustness that you cannot achieve with a normal constant.

Answer 3

Enumerated data types (enums) are a group of named constants. When we pass values into functions, it is sometimes desirable to limit the range of values that may be passed. To achieve this we use an enum.

For example, suppose we have the following function:

std::string get_suit(int id)

{

switch(id)

{

case (0): return "clubs";

case (1): return "hearts";

case (2): return "spades";

case (3): return "diamonds";

}

return "";

}

The above example is unsatisfactory because if we pass a value less than 0 or greater than 3, the return value is an empty string, which means we must test the value before calling the function, or test the result, to ensure the call is valid at runtime. That's an expensive overhead if we call this one function many times over.

To limit the range of possible values we can use an enum:

enum suit { clubs, hearts, spades, diamonds };

Now we can rewrite the function as follows:

std::string get_suit(suit id)

{

switch(id)

{

case (clubs): return "clubs";

case (hearts): return "hearts";

case (spades): return "spades";

case (diamonds): return "diamonds";

}

}

Note that we do not need a default case nor do we need a return statement at the end of the function because every possible case is now addressed by the switch.

In most enum declarations we do not need to assign specific values to each element; they are automatically enumerated in the order they are listed, with values 0, 1, 2, 3 and so on. However, we can assign specific values to any element. For instance, suppose we want an enumeration to begin at -1 rather than 0:

enum result { fail=-1, pass };

In the above example, pass has the value 0. We could also write this definition in reverse:

enum result { pass, fail=-1 };

Whenever we assign a value to any element, all subsequent values will automatically enumerate from that point on. Thus a 1-based enumeration can be achieved as follows:

enum suit { clubs=1, hearts, spades, diamonds };

If we need to skip one or more values, we simply start a new enumeration:

enum funkey { f1=1, f2, f3, f5=5, f6, f7, f9=9 };

Here we've enumerated some function key identifiers. We're not interested in f4 or f8, but we would still like the values to match the function key id. It's not necessary to do this since we can just use the names f1, f2, etc, but it ensures some consistency, especially when debugging. If the value of a funkey is 5 then we know f5 was assigned to the funkey.

We can also use the same value for more than one element:

enum result { fail=-1, pass, error=-1, success };

Here, fail and error have the same value, -1, while pass and success also have the same value, 0.

Whether you assign values or not, there is no need to keep track of those values -- you can simply use the enum element names. However, by using the default, 0-based enumeration (0, 1, 2, 3, ...) you can also use an enum as an array subscript.