Other Integer Types

• There are at least two other integer types
  • characters or char
  • booleans or bool
• Both of these types have "different" behavior at least part of the time.
• Booleans
  • reference.
  • Limited to the values true or false.
  • Direct I/O on bools is flaky at best
    • In general false maps to 0
    • true maps to not 0.
    • But cout << boolalpha; will print true or false.
  • Bools are used mostly for loops and if statements,
  • But they have other uses as well.
  • The comparison operators (==, !=, <=, <, >, >=) all produce boolean values.
  • Operators
    • && or and
    • || or or
    • ! or not
    • But not the bitwise operators &, |, ~
    • I prefer and, or over the characters so I don't get confused with the bitwise operators.
    • I use both ! and not, but try to use not in class.
  • In c, and early c++ there were no booleans, so sometimes int was used in the place of a bool.
  • Take a look at boolTables.cpp
• character types char
  • Characters (char) are at least 1 byte. (8 bits).
  • In modern cpp, (since 11) there are char16_t and char32_t for internationalization.
    • We will skip these for now.
  • Characters can be signed or unsigned. ( -128 to 127 or 0 to 255)
  • Normally characters store the ASCII value of the character they represent.
  • Literal characters are surrounded by ''
    • 'a' has ASCII code 97.
    • '0' has ASCII code 48.
    • '\n' has ASCII code 10 and is the new line character.
    • '\t' has ASCII code 9 and is the tab character.
    • '\r' has ASCII code 13 and is the carrage return.
  • Character I/O
    • stream extraction (>>) :
      • Skip whitespace
      • read in first non-whitespace character.
      • stop.
    • cin.get()
      • reference.
      • cin.get(char_type)
      • char_type = cin.get()
      • Reads the next available character.
• Take a look at charDemo.cpp.
• static_cast
  • This is one of the type conversion operators.
  • This allows us to convert from one type to another.
  • reference.
  • When the programmer does this it is called type casting or casting.
  • The compiler can do it as well, it is called coercion
  • We need to be careful when type casting.
• Type casting
  • Moving from a smaller type to a larger type is fine.
    • int_type = static_cast<int>(character_type)
    • We have sufficient bits to represent the new value.
      • Moving from a larger type to a smaller type is problematic
        • char_type = static_cast<int>(int_type)
        • We might not have sufficient bits to hold all of the data.
    • In my example, I wanted to print the ascii values, not the ascii character, so I cast it from a char to an int.
    • There are some old libraries that behave strangely for characters
      • is* reference.
      • int isdigit( int ch ); checks to see if a character is a digit or not.
        • But the input is an int
        • And the output is an int.
        • It probably should be bool is digit(char ch);, but it is not.
        • This comes from c, and we need to put up with it.
        • the proper use is probably static_cast<bool>(isdigit(static_cast<int>(character)))
        • But we can probably do just isdigit(character) and let the compile coerce it fr us.
        • You should know this family of functions.
      • toupper and tolower.
        • int toupper(int ch)
        • Converts any "letter" to upper case.
        • But does not change any other characters.
        • THIS DOES NOT WORK ON A STRING LEVEL, only a character level.
        • Again, static casts might be involved.
    • Old style casts
      • In c the style was var = (type) expresion
      • intType = (int) charType
      • Old c++ the style was var = type (expression)
      • intType = int (charType)
      • Both of these have problems and should be avoided.
    • Compiler flags
      • These allow the compiler to warn us when we are doing something bad.
      • -Wold-style-casts: warn if using an old style cast.
      • -Wconversion: warns if we might lose precision from a conversion.
      • This can be put in a line in the Makefile

        CXXFLAGS = -Wold-style-cast -Wconversion
                

      • Look at the Makefile.
      • Look at letterId.cpp