CSCI 1110 - C++ Lecture Notes
Chapter 10 - Simple Data Types

Built-In Simple Types

Constants

Bitwise Operators

The ?: Operator

Operator Precedence

Enumeration Types 

---

Built-In Simple Types

• A Simple or Atomic Data Type is a data type in which each value is indivisible.
  
  
• Simple types that are build into C++ are:

     Integral:                                          Floating:
        char                  float
        short                 double
        int                   long double
        long
        enum
        unsigned char
        unsigned short
        unsigned int
        unsigned long 



• sizeof can be used to determine the size of any type (or variable). The number of bytes allocated to each simple type may be different on different systems:

 
 System 1:                                   System 2:
  sizeof(char) = 1    sizeof(char) = 1
  sizeof(short) = 2   sizeof(short) = 2
  sizeof(int) = 4     sizeof(int) = 2
  sizeof(long) = 8    sizeof(long) = 4 


• The range of each of the simple types is determined by the size of the memory allocated to them. The following is for one system:
  
  

Type	Size	Minimum	Maximum
char	1	-128	127
unsigned char	1	0	255
short	2	-32768	32767
unsigned short	2	0	65535
int	2	-32768	32767
unsigned int	2	0	65535
long	4	-2,147,483,648	2,147,483,647
unsigned long	4	0	4,294,967,295

 


• limits.h contains constants for the maximum and minimum values for the simple types for the system you are using:  CHAR_MAX, CHAR_MIN, SHRT_MAX, SHRT_MIN, INT_MAX, INT_MIN, LONG_MAX, LONG_MIN, UCHAR_MAX, USHRT_MAX, UINT_MAX, ULONG_MAX.

Constants

• Numeric constants can be specified in three different number bases in C++ - decimal, octal (base 8) and hexadecimal (base 16).
  
  
• Decimal constants are written as a string of decimal digits (0 - 9) and must begin with a non-zero digit. They may be written with an optional sign (+ or -).

 
Examples of decimal constants:
                    1
                    56
                    -12897 


• Octal contants are written as a string of octal digits (0-7) and must begin with the digit 0.

 

Examples of octal constants:
                    0
                    056
                    07777 



• Hexadecimal contants are written as a string of hexadecimal digits (0-9, A-F) and must begin with  0x

 

Examples of octal constants:
                    0x10
                    0x56
                    0xFFFF

• Each hexadecimal digit corresponds to 4 bits:
  
  

Hexadecimal Digit	Binary Value	Decimal Value
0	0000	0
1	0001	1
2	0010	2
3	0011	3
4	0100	4
5	0101	5
6	0110	6
7	0111	7
8	1000	8
9	1001	9
A or a	1010	10
B or b	1011	11
C or c	1100	12
D or d	1101	13
E or e	1110	14
F or f	1111	15

 

• Decimal, Octal and Hexadecimal are all positional number systems. A positional number system is one where the value of a digit in a number depends on it position in the string of digits.
  
  
• The decimal number 12345 is interpreted as:

        5 * 10⁰  = 5 * 1       =        5
      + 4 * 10¹  = 4 * 10      =  +    40
      + 3 * 10²  = 3 * 100     =  +   300
      + 2 * 10³  = 2 * 1000    =  +  2000
      + 1 * 10⁴  = 1 * 10000   =  + 10000
                                  = 12345
 



• Hexadecimal numbers are interpreted the same way, except that the number is computed as powers of 16, rather than 10. 0x12AF is interpreted as:

 

        F * 16⁰  = 15 * 1       =      15
      + A * 16¹  = 10 * 16      =  +  160
      + 2 * 16²  =  2 * 256     =  +  512
      + 1 * 16⁴  =  1 * 4096    =  + 4096
                                =    4783

• To specify that a constant is a particular type (i. e. unsigned ) it is often necessary to append a letter to the constant. The letters U and L (upper or lower case) tell the C++ compiler that a constant is unsigned or long.

Examples:

    123            is a signed int(by default)
    123U           is an unsigned int
    123L           is a signed long
    123UL          is a unsigned long
 



• Floating constants can be written in two main formats: fixed and exponential. Exponential floating constants are written using the E notation:

 

Examples of floating constants: 



Constant	Type	Remarks
6.83	double	Floating point constants are double by default
6.83F	float	Explicit float constants end in F or f
6.83L	long double	Explicit long double constants end in L or l
4.35E-9	double	Exponential notation meaning 4.35X10-9 .

 

Bitwise Operators

• Bitwise operators are used for manipulating individual bits within a memory cell.
  
  
• << and >> are shift operators. << shifts bits to the left and >> shifts bits to the right.

 

Example:

    char n = 0x5A;    // 01011010 binary

    a = n << 1;       // 10110100
    b = n >> 1;       // 00101101
    c = n >> 4;       // 00000101 



• Note that shifting right is equivalent to dividing by powers of 2 and shifting left is equivalent to multiplying by powers of 2.

 

Example:

    char n = 5;       // 00000101 binary

    a = n << 1;       // 00001010 == 0x0A == 10
    b = n >> 1;       // 00000010 == 0x02 == 2
    c = n << 4;       // 01010000 == 0x50 == 80 



• Notice that in C++, operators << and >> are used both for input and output and for shifting. The multiple use of operators is known as operator overloading.
  
  
• The bitwise logical operators are similar to the logical operators we have studied earlier:
  
  

 

Operator	Description
&	Bitwise AND
|	Bitwise OR
^	Bitwise EXCLUSIVE OR
~	Complement (invert all bits)

 

• Definition of bitwise logical operators:
  
  

 

bit a	bit b	a & b	a | b	a ^ b	~a
0	0	0	0	0	1
0	1	0	1	1	1
1	0	0	1	1	0
1	1	1	1	0	0

 

Examples:

    char n = 5;       // 00000101 binary
    char m = 6;       // 00000110 binary

    a = n & m;        // 00000100 == 0x04
    b = n | m;        // 00000111 == 0x07
    c = n ^ m;        // 00000011 == 0x03
    d = ~n;           // 11111010 == 0xFA
 



• The bitwise logical operators are used to examine or set specific bits in a number. These operations are called masking.

 
Examples:

    // Determine if n is an odd number
    if (n & 0x0001 == 0x0001)
        . . .
    else
        . . .

    // Make n an even number
    n = n & 0xFFFE;

    // Make n an odd number
    n = n |0x0001;

    // Swap the contents of m and n
    // without using another variable
    m = 0x2A;    // 00101010
    n = 0xA5;    // 10100101
    m = m ^ n;   // 10001111
    n = m ^ n;   // 00101010 = 0x2A
    m = m ^ n;   // 10100101 = 0xA5

The ?: Operator

• The ?: operator is sometimes called the conditional operator. It takes three operands. The first operand is a logical expression. If it is TRUE, the value of the expression is operand 2. If the first operand is FALSE, the value of the expression is operand 3.

Example:

        is equivalent to:

    if (a > b)
        max = a;
    else
        max = b;

Operator Precedence

•  The following table shows the operators that we have looked at so far in order from highest to lowest precedence. It also show their associativity. The associativity of operators is how they group when there are more than one of them at the same precedence level.
  
  

Operator	Associativity
( )	Left to right
unary: ++ -- ! + - (cast) sizeof ~	Right to left
* / %	Left to right
+ -	Left to right
< <= > >=	Left to right
<<  >>	Left to right
== !=	Left to right
&	Left to right
^	Left to right
|	Left to right
&&	Left to right
||	Left to right
?:	Right to left
= += -= *= /= %= <<= >>= &= |= ^=	Right to left

 

• The statements

    n += x = 7;

associates from right to left. Therefore it first stores 7 in x and then adds that value to n.

Enumeration Types

• C++ allow the user to define new simple types by listing (enumerating) the literal values that make up the domain of the type.
  
  
• Enumerated literal values must be identifiers, not numbers.
  
  
• An Enumeration Type is a user-defined data type whose domain is an ordered set of literal values expressed as identifiers.
  
  
• An Enumerator is one of the values in the domain of an enumeration type.
  
  
• Example:

    enum Days {SUN, MON, TUE, WED, THU, FRI, SAT};
 
 

The value of SUN is 0, MON is 1, TUE is 2, etc.

   enum Month {JAN = 1, FEB, MAR, APR, MAY,
               JUN, JUL, AUG, SEP, OCT,
               NOV, DEC};

The value of JAN is 1, FEB is 2, etc.
 

• The enumerated values can be instead of their numeric equivalents.

    Days today;
    today = TUE; 



• Arithmetic with enumerated values is not as might be expected. You cannot increment or add a constant to change from one value to another. You can however use type casting to accomplish the same thing:

Examples:

    Days today;
    today = TUE;
    today = Days(today + 1); // today++ won't work

    for (today = SUN;
         today <= SAT;
         today = Days(today + 1)
    {
        cout << today << endl;
    }

outputs the numbers 0, 1, 2, 3, 4, 5, 6; not the literals. 



• Comparisons with enumerated values work fine:

 

Examples:

    if (today == TUE)
        . . .
    if (today < FRI)
        . . . 


Enumerated values can be used with a switch statement:

    enum Days {SUN, MON, TUE, WED, THU, FRI, SAT};
    Days today;
    int  weekday;
 
    . . .
    switch (today)
    {
        case SUN:
        case SAT:
            weekday = FALSE;
            break;

        default:
            weekday = TRUE;
    }