Types

1
Types

• Chapter 2

2
Objectives

• Observe types provided by C
• Literals of these types
• Explain syntax rules for identifier names
• Study variables and constants
• What they are
• How they differ
• How to declare
• How to use
• Investigate internal representations
• First look at class attribute variables

3
Types and Declarations

• Fundamental Types
• Integers (whole numbers, negatives)
• int
• Integer variations
• short, long, unsigned
• Reals (fractional numbers)
• float, double, long double
• Characters (letters, digits, symbols,
  punctuation)
• char
• Booleans (logical values, true and false)
• bool

4
Integer

• Memory used for an int depends on word size used
  by the hardware
• Usually 16, 32, or 64 bits used
• 16 Bits (2 bytes) short int
• Range -32768 32767
• 32bits (4 bytes) long int (or long)
• Range -2137483648 2137483647 (maybe 64)

One bit used for the sign
5
Integer

• Integers can be specified as unsigned
• Then the sign bit not needed
• Gives larger positive range
• unsigned short (16 bits)
• Range 0 65535
• unsigned long (32 bits)
• Range 0 4294967295

6
Integer Literals

• Decimal integers
• Sequence of digits without a decimal point
• Octal integers
• Sequence of digits beginning with a 0
• Base 8
• Hexadecimal integers
• Sequence of digits beginning with an X
• Base 16

7
Reals

• float
• Usually a 32-bit value (4 bytes)
• double
• A 64-bit value (8 bytes)
• long double
• A 96- or 128-bit value

The programmer should choose which type based on
degree of precision desired for the object
8
Reals

• Values are stored internally in scientific
  notation (base 2)
• A sign for the number
• Significant digits of the number
• The power of 10
• Sign for the power

9
Reals

• Literal values (real Literals are treated as
  double)
• A sequence of digits with leading sign,
  containing a decimal point
• Scientific notation any one of the following
  forms
• 0.12e11
• 1.2E10
• 12.0E9
• 12.e9
• 12E9

10
Characters

• char type
• Represents individual characters
• See ASCII character set in Appendix A
• Characters represented in memory by numeric
  values
• Character literals
• Characters enclosed in single quotes'X' '7'
  'gt' 'e'

11
Characters

• Escape characters
• A backslash \ combined with another character
  hold special meaning

Character C Escape Sequence
Newline \n
Horizontal tab \t
Vertical tab \v
Backspace \b
Carriage Return \r
Form Feed \f
Alert (beep) \a
12
Strings

• Need include ltstringgt using namespace std
• A sequence of characters
• Enclosed in double quotes "Hi Mom
• Can include escape characters "\nThe answer is
  "
• Warning
• "A" is a string literal
• 'A' is a character literal

13
Identifiers

• Names given to software objects
• Rules
• Must not be C keywords (see Appdx B)int, if,
  while,
• Must start with a letter (or the underscore _ )
• Followed by numerals, letters, underscore
• Recommendation
• Use meaningful identifiers
• Go for longer names, rather than shorter

14
Identifiers

• C is case sensitive
• firstName is not the same as firstname
• Typical usage
• Constants are all caps PI
• Variables
• Start with lower case
• Capitalize first letter of successive
  words monthlyElectricCharge

15
Object Categories

• There are three kinds of objects
• Literals
• unnamed objects
• having a value
• (0, -3, 2.5, 2.998e8, A, Hello\n, ...)
• Variables
• named objects
• values can change during program execution
• Constants
• named objects
• values do not change during program execution

16
Literals

• int literals are whole numbers
  -27, 0, 4, 4,012,0xA3B
• double literals are real numbers, and can be
• fixed-point -0.333, 0.5, 1.414, ...
• floating-point 2.998e8, 0.2998e9, ...
• There are just two bool literals false, true
• char literals are single ASCII characters
  A, a, 9, , ?, ...
• string literals are ASCII character sequences
  Hello, Goodbye, Goodbye\n, ...

17
Constants

• Declaration of software objects that remain
  constant
• const double HOURLY_WAGE 6.75
• Rules
• const is a keyword
• Specify type
• Specify the name (caps recommended)
• Must be initialized with value at declaration

18
Constants

• Reasons to use constants
• Improve readability of the source code
• Facilitate program modification
• Good programming practice
• Place all constant declarations at beginning of
  function where used
• See some predefined constants in ltclimitsgt and
  ltcfloatgt libraries. (page 43)

19
Variables

• Give a name to a memory location
• Compiler accesses specific memory location when
  program uses a given variable
• Refer to objects in the program for which the
  value can change
• Declarationtype variableName // ortype
  variableName initializer_expression

20
Variables

• Variables Declaration
• Can be either initialized or uninitialized...
• If variable is uninitialized Contents must be
  considered "garbage value"
• Examples
• int age 18
• double GPA 3.25, credits
• char letterGrade A
• bool ok, done false

21
int Representation

• Integers are often represented in the
  twos-complement format,
• High-order bit indicates the numbers sign
• 210 00000000000000102
• 110 00000000000000012
• 010 00000000000000002
• -110 11111111111111112
• -210 11111111111111102
• We show 16 bits, but 32 or 64 are common.

22
unsigned Objects

• Some objects have values that are never negative,
  
• C provides the unsigned type
• 00000000000000002 010
• 00000000000000012 110
• 00000000000000102 210
• ...
• 11111111111111102 6553410
• 11111111111111112 6553510
• No sign bit, numbers can be twice as big.

23
int vs. unsigned

• Using 32 bits, int values range from
  
• -231 (-2147483648) to 231-1 (2147483647),
• unsigned values range from
• 0 to 232-1 (4294967295).
• An int value loses one of its bits to the sign,
  
• Maximum int value is about half of the maximum
  unsigned value.

24
double Objects

• Real values are often represented in 64 bits
• Use the IEEE floating point standard

25
double Objects

• Overflow
• Exponent is too large
• Not enough bits to represent
• Underflow
• Number is so small
• Not enough bits to represent negative exponent

26
char and String Objects

• Characters represented internally with binary
  codes
• 8 bits only 128 characters
• Strings stored as a sequence of these binary codes

27
char and String Objects

• Unicode uses 16 bit codes
• Possible to represent more than 65,000 characters
• Can includespecialcharacters

28
Booleans

• Only two values
• true and false
• true stored as 1
• Anything non zero will be interpreted as true
• false stored as 0
• Could be stored in a single bit
• Usually stored in a word or byte