Enumerated Types

• This is covered in section 10.2 of the book.
  • However the type presented is not the best.
  • In c++11 a better enumerated type was introduced.
  • We will use that type in our classes.
  • See this reference but go to the scoped enumerated section.
• You are required to use scoped enumerators for this class.
• In RPGs any number of things are identified by a list of classifiers.
  • Consider this table: Size Categories

    Size	Space	Examples
    Tiny	2$\frac{1}{2}$ by 2$\frac{1}{2}$ ft.	Imp, Sprite
    Small	5 by 5 ft.	Giant Rat, Goblin
    Medium	5 by 5 ft.	Orc, Werewolf
    Large	10 by 10 ft.	Hippogriff, Ogre
    Huge	15 by 15 ft.	Fire Giant, Treant
    Gargantuan	20 by 20 ft. or larger	Kraken, Purple Worm

    (Taken from Roll20.net.)
• I would like to build a game that includes the size of animals classified as Tiny ... Gargantuan.
  • In other words, I would like a SizeT type.
• How could I do this?
  • I could just pass strings.

    • using SizeT = string; 

    • But I bet I mispell gargantuan more than I get it right.
    • I have problems with case Large, LARGE or large
    • They take more space than they should.
      • Gargantuan takes at least 10 characters or 80 bits.
      • To distinguish between 6 things I need 3 bits.
    • AND there is no way for the compiler to enforce correctness.
  • I could use constant strings

    • 
      using SizeT = string;
      
      const string TINY{"tiny"};
      const string SMALL{"small"};
      ...
      const string GARGANTUAN{"gargantuan"} 

    • This gets rid of the first two problems above, but not the others.
  • I could use integers

    • using SizeT = int;
      
      const int TINY{0};
      const int SMALL{1};
      ...
      const int GARGANTUAN{5} 

    • Again, better for space.
    • But what if I have a copy and paste error?

    • const int TINY{0};
      const int SMALL{0};
      

    • Suddenly TINY and SMALL are the same thing.
• A solution, the enum or enumerated types.
  • You can declare your own data type that is mapped to the integers, using any integer like type.
  • enum class|struct identifier [:type] {identifier[=constexpr], ...};
    • enum is a reserved word.
    • using class or struct makes it a scoped enumeration.
    • Identifier: CammelCaseT please.
    • the type is optional
    • Each Enumerator
      • ALL_UPPER_CASE please.
      • =value is optional
      • Skip unless you have a reason.
• Example:

  • enum class SizeT:char {TINY, SMALL, MEDIUM, LARGE, HUGE, GARGANTUAN, NONE};

• This declares a new type SizeT.
  • The range is the list of enumerators.
  • The operations are
    • Comparison
    • Can be passed as parameters and returned from a function.
    • Variables and constants can be declared.
  • But
    • No I/O
    • No math
• Let's create a simple game.
  • Two creatures approach each other.
    • If they are the same size, they make friends.
    • If they are one size different, they look at each other in amazement.
    • If they are two or more sizes different, they fail to notice each other.
  • Take a look at, or write simpleGame.cpp.