Simple User Defined Types

• Section 10.2 page 466, read it.
• We can set up a nickname for a type.
  • This can save typing.
  • It can make code easier to read.
  • It can make code more flexible.

• typedef oldtype newtype; 

  • oldtype is an existing type, even if user defined.
  • newtype is an identifier.
    • I would follow CammelCaseT (with the T at the end to indicate type)
  • This declaration should go at the top of the program
    • After using namespace... so you get all the standard library items.
    • Before any constant or function definitions (so you can use it)
    • Remember in C++ everything must be declared before it is used.
  • You can now use this anywhere you would a type.
  • size_t is probably a typedef.
  • Remeber this, we will use it later.
  • Look at typedef.cpp
• Enumerator types
  • Consider problem 1 page 510
    • Write a c++ program that asks the user to enter his or her weight and the name of a planet. The following table gives the factor by which the weight must be multiplied for each planet. The program should output an error message if the user doesn't input a correct planet name. The prompt and the error message should make it clear to the user how a planet name must be entered. Be sure to use proper formatting and appropriate comments in your code. The output should be labeled clearly and formatted neately.

      Planet Name	Factor
      Mercury	0.4155
      Venus	0.8975
      Earth	1.0
      Moon	0.166
      Mars	0.3507
      Jupiter	2.5374
      Saturn	1.0677
      Uranus	0.8947
      Neptune	1.1794
      Pluto	0.0899

  • A quick design for the code might be

  • 
    main:
       GetPlanetName
       GetWeight
       CalculateWeightOnPlanet
       PrintResults
    
    GetPlanetName
       do 
          Prompt
          Get value from user
       while ValidPlanet != none
       return planet 
    
    ValidatePlanet
       // input: a string, the name of the planet
       // output:  some type of variable 
       change planet name to all lower case.
       if the planet is in the table, return the plant 
          // this will need to be a if-else if ... 
       else return  none
    
    CalculateWeightOnPlanet
       // input a valid planet
       //       a valid weight on Earth
       // Output the weight on the other plannet.
    
       Get Conversion Factor (based on planet)
       Perform Multiplication
       Return value
            

  • Note, in most cases we would be shipping some identification for the planet.
    • We could ship the string everywhere.
      • This is bad for several reasons.
        • We always need to compare with a if-elseif not a case.
        • Strings are not an efficient way to store essuntually label information
          • They potentially take up many spaces "omicron persei 8"
            • This is also expensive to compare.
          • They potentially have MANY different representations.
            • All upper
            • All lower
            • First letter upper for each word.
            • The number 8 or spell it out.
          • They have potential for misspelling
      • How about the following

        • using namespace std;
          
          const int NONE = 0;
          const int MERCURY = 1;
          const int VENUS = 2;
          ...  

        • Is there a chance you might

        • const int SATURN = 5;
          const int URANUS = 5;
          ...  

        • Is there any way to quickly renumber when they build a second moon?
        • In general constants are good
          • They are small (32 bits or less)
          • You can use switch statements (much cleaner)
        • But
          • Renumbering is a pain.
          • And there is no way the compiler could ever validate this, they are just ints.
  • A better way to solve this problem is with an enumerateion type
    • Caution, we are talking about unscoped or "old" enumeration types.
      • Scoped or class based enumerations are a newer feature.
      • But I want to stick with the book.
      • And neither are particularly strong.
      • And the old type shows up more places than the new.
    • This is a user defined type.
    • It is really just a convienence for the constant type above.
      • enum type_name { value1, value2, ...valueN};

      • enum PlanetT {NO_PLANET, MERCURY, VENUS, EARTH, MOON, 
                      MARS, JUPITER, SATURN, URANUS, NEPTUNE, PLUTO} 
        
        PlanetT ValidatePlanet(string planetName);
        float CalculateWeight(PlanetT destinationPlanet, float weightOnEarth);
        
        ...
        int main() {
            PlanetT destination = NO_PLANET;
        } 

  • Operations supported on enumerable types
    • Assignment
    • Math, but you will probably be flagged with conversion problems.
    • Comparsion
    • I/O not directly.
• Look at enum.cpp
• Look at planets.cpp