Enumerated Types

Enumerated types allow you to build your own types that are equivalent to the integers.
But you can name the values.
Again there are two types of enumerated types in c++
- Unscoped enumerations are discussed in the book.
- Scoped or strong enumerations are a C++11 addition.
  - See this reference.
- In general scoped enumerations are preferred.
- And I expect you to learn and use scoped enumerations.
The problem
- I have a finite list of things I want to name and use in my program.
  - number types in a calculator
  - colors
  - Days of the week.
- I want to be able to pass an item of that list as a variable.
  - ```
  void PrintNumberInBase(int number, BaseTypeT base) {
  } 
```
- What type should type should the item be?
- Strings?
- ```
using BaseTypeT = string;
void PrintNumberInBase(int number, BaseTypeT base) {
    if (base == "ten") {
        cout << number;
    } else if (base == "trinary") {
        cout << IntToTrinary(number);
    } else if (base == "hex") {
        cout << IntToHex(number);
    } else if (base == "urnfield") {
        cout << IntToUrnfield(number);
    } ...
    } else {
        cout << "Unknown base " << base << endl;
    }
} 
```
- But strings take up quite a bit of memory.
- And adding something to the list is "hard"
- And there are the upper/lower case and spelling problems.
- And the compiler will not provide any checking for bad "values"
- And I have to use the if-else if - else structure.

I could use integers

using BaseTypeT = int;
void PrintNumberInBase(int number, BaseTypeT base) {
    switch(base) {
        case 10:
            cout << number;
            break;
        case 3:
            cout << IntToTrinary(number);
            break;
        case 16:
            cout << IntToHex(number);
            break;
        case 222:
            cout << IntToUrnfield(number);
            break;
        ...
        default: 
            cout << "Unknown base " << base << endl;
    }
}

But the numbers don't name anything.
They make sense in some place, what is 222?
And there is no real check for bad "values"

I could fix this with some constants

using BaseTypeT = int;
const int BASE_10 = 1;
const int BASE_3 = 2;
const int BASE_16 = 3;
const int BASE_URNFIELD = 4;

void PrintNumberInBase(int number, BaseTypeT base) {
    switch(base) {
        case BASE_10:
            cout << number;
            break;
        case BASE_3:
            cout << IntToTrinary(number);
            break;
        case BASE_16:
            cout << IntToHex(number);
            break;
        case BASE_URNFIELD:
            cout << IntToUrnfield(number);
            break;
        ...
        default: 
            cout << "Unknown base " << base << endl;
    }
}

A problem here is what if I added

        ...
const int BASE_URNFIELD = 4;
const int BASE_MAYAN = 4;

This is a copy and paste error.
But no compiler check can find this.

Enumerated types provide an alternative.
- A programmer declares an enumerated type.
- The compiler "assigns" enumerable values to the type.
- No duplicate "values" are permitted.
Scoped/Strong enumerable types (you must use these)
- This declaration is what we will use
```
enum class ClassTypeName { enumerator,  enumerator, ... NONE};
enum class BaseT {TEN, THREE, SIXTEEN, MAYAN, URNFIELD, BINARY, NONE};
        
```
  - The type name is BaseT
  - The enumerators or domain
    - are all upper case
    - Include NONE at the end.
Working Example: A card game, use an enum for the suit.
- Take a look at SuiteT.h
- Declare the enumerated type SuiteT
  - ```
  enum class SuitT { HEART, SPADE, DIAMOND, CLUB, NONE}; 
```
- Individual enumerators are accessed like a scoping operation
  - ```
  const SuitT  FIRST_SUIT = SuitT::HEART; 
```
- The definition of FIRST_SUIT is very helpful for looping through all of the suits available.
  - ```
  SuitT i;
  
  for(i = FIRST_SUIT; i != SuitT::NONE; i = NextSuit(i);
              
```
- Enumerated types do support comparison.
- Notice the header for NextSuit()
  - Enumerated types do not support math (+,-,*, ...)
    - But you can cast them to an integer.
  - I usually build this function to allow me to loop through all of my enumerators.
  - You can not "increment" string enumerators, so we will write code to do this.
- Unless you do something else, the enumerators correspond to 0,1,2,...
  - So casting SuitT::NONE to an int, or in this case a size_t, will give us the number of valid suits.
  - ```
  const size_t SUIT_COUNT = static_cast(SuitT::NONE);
          
```
- This constant is also very helpful for declaring arrays to hold all of the suits.
- Enumerated types do not support I/O
- I usually declare a StringTo and ToString function for my enumerators
  - Note the function prototypes.
  - These are useful for debugging if nothing else.
By the way, I am going to concentrate ALL of my enumerated code in two files.
- Using the interface provided, I can add new enumerators and most code (except for special actions based on the different enumerators), will still work.
Take a look at SuitT.cpp
Take a look at suitTest.cpp