The Enumerated Type

• Enumerated types are discussed in the book starting on page 19.
• Also cppreference.com: enum.
• I use enumerated types.
  • They lead to self documenting code.
  • They eliminate some out of range errors.
• But i use the modern scoped or strong enumerated types.
  • And you will to if you wish to pass that portion of the class.
• enum [class|struct] identifier [: type] { enumerator[=constexpr], ...}
  • pick one, class or struct
  • the type is optional, but must be enumerable (int, char, short, ...)
  • Assigning a value to the enumerator is optional.
    • I know of cases where this is useful.
    • Ours might be one, but I don't want to.

• enum class BodyPartT {BODY, HEAD, LEG, EYE, ANTENNA, TAIL, NONE}; 

• Local Conventions
  • End types with a T (BodyPartT)
  • Enumerators are all upper case EYE
• Must be scoped to use

• BodyPartT currentPart{BodyPartT::HEAD};
  
  currentPart = BodyPartT::EYE; 

• In strong enumerated types, coercion is gone, must cast everything.

• currentPart = static_cast<BodyPartT>(3);  // this is ok, but be careful.
  int i = static_cast<int>(currentPart);    // this is ok. 

• When I build one of these, I generally build
  • I usually add a constant for the first body part

    • const BodyPartT FIRST_BODY_PART{BodyPartT::BODY}; 

  • I usually add a max constant as well

    • const size_t BODY_PART_COUNT {static_cast<size_t>(BodyPartT::NONE)}; 

  • I add a value NONE at the end so loops work.

    • BodyPartT i{FIRST_BODY_PART};
      
      for( i = FIRST_BODY_PART; i != BodyPartT::NONE; ++i) {
      } 

  • To make this work, we need to overload the ++ operator.
    • This is discussed on page 547 of the book.
    • What does overload an operator mean?
    • How do you overload an operator?
      • return_type operator operator_symbol( params) { }
    • What does ++i mean?
      • Increment i then return the modified value.
    • What does i++ mean?
      • Increment i but return the previous value.
    • There is special syntax for overloading these two

      • // this is code for ++i
        // the parameter needs to be  pass by reference, why?
        BodyPartT operator ++(BodyPartT & b) {
            
            if (b < BodyPartT::NONE) {
                b = static_cast(static_cast(b)+1);
            }
            return b;
        }
        
        // this is code for i++
        BodyPartT operator ++(BodyPartT & b, int) {
            BodyPartT oldValue{b};
            if (b < BodyPartT::NONE) {
                b = static_cast(static_cast(b)+1);
            }
            return oldValue;
        } 

  • A const array of strings associated with this enumeration

    • const string BODY_PART_NAMES[]{"body", "head", "leg", "eye", "antenna", "tail", "none"};

  • I build a function that converts from a enum to a string.

    • string BodyPartTToString(BodyPartT b) {
          string name{"none"};
          if (b >= BodyPartT::BODY and b <= BodyPartT::NONE) {
               name = BODY_PART_NAME[static_cast(b)];       
          }
          return name;
      } 

  • Finally this allows me to overload the stream insertion operator
    • See page 549

    • ostream & operator << (ostream & s; const BodyPartT & b) {
           s << BodyPartTToString(b);
           return s
      } 

  • You may want other functions, depending on how you are using the enumerated type.
    • In this case I might want a enum to int so I can index into an array
      • How will you represent a player?
    • I might want a string to enum if I am doing input
• I will want to put all of this into a .h and .cpp file, just to keep things clean.
• I will probably want to write at least a minimal test driver to make sure that it all works.
• I really don't want to put any game mechanics in this collection.
• I probably don't want any other I/O in this collection.