Chapter 6

Data Types

ISBN 0-321-33025-0
Definitions

• A data type defines a collection of data objects

and a set of predefined operations on those
objects
• A descriptor is the collection of the attributes of a
variable
• An object represents an instance of a user-
defined (abstract data) type

Copyright © 2006 Addison-Wesley. All rights reserved. 1-2

Data Types

• Almost all programming languages provide

a set of primitive data types
– Types not defined in terms of other data types
– Types that are defined in the language
– Some primitive data types are merely reflections
of the hardware
– Others require a little non-hardware support
• Structured data types are built out of
primitive types

Copyright © 2006 Addison-Wesley. All rights reserved. 1-3

Integer Types

• Almost always an exact reflection of the

hardware so the mapping is trivial
• There may be as many as eight different
integer types in a language
• Java’s signed integer sizes: byte, short,
int, long
• C/C++ have unsigned versions of the same
type

Copyright © 2006 Addison-Wesley. All rights reserved. 1-4

Representing Integers

• Positive integers are easy - convert the

number to base 2
• How do you handle negative numbers when
you have to use 0s and 1s?
• Several possibilities
– Sign bit
– Ones complement
– Twos complement - this is the one that is used

Copyright © 2006 Addison-Wesley. All rights reserved. 1-5

Representing negative integers

• Sign bit

• Ones complement

Copyright © 2006 Addison-Wesley. All rights reserved. 1-6

Twos Complement

• To get the binary representation, take the

complement and add 1

Copyright © 2006 Addison-Wesley. All rights reserved. 1-7

Floating Point Types

• Model real numbers, but only as

approximations
• Languages for scientific use support at
least two floating-point types (e.g., float
and double; sometimes more
• Usually exactly like the hardware, but not
always
• IEEE Floating-Point Standard 754
– 32 and 64 bit standards

Copyright © 2006 Addison-Wesley. All rights reserved. 1-8

Representing Real Numbers

• We could convert the decimal number to

base 2 just as we did for integers
• But, how do we represent the decimal
point?
• Using a fixed number of bits for the whole
and fractional parts severely limits the
range of values we can represent
• Use a representation similar to scientific
notation

Copyright © 2006 Addison-Wesley. All rights reserved. 1-9

Floating Point Representation

• Normalize the number so the mantissa has the form

1.Fraction where Fraction is a sequence of binary bits.
• Use one bit to represent the sign (1 for negative)
• Use a fixed number of bits for the exponent which is offset
to allow for negative exponents
– Exponent = exponent + offset
• (-1)sign 1.Fraction x 2Exponent

Copyright © 2006 Addison-Wesley. All rights reserved. 1-10

Fixed Point Types (Decimal)

• For business applications (money) round-

off errors are not acceptable
– Essential to COBOL
– C# offers a decimal data type
• Store a fixed number of decimal digits
• Operations generally have to be defined in
software
• Advantage: accuracy
• Disadvantages: limited range, wastes
memory
Copyright © 2006 Addison-Wesley. All rights reserved. 1-11
Other Primitive Data Types:

• Boolean
– Range of values: two elements, one for “true” and one for
“false”
– Could be implemented as bits, but often as bytes
• Character
– Stored as numeric codings
– Most commonly used coding: ASCII
– An alternative, 16-bit coding: Unicode
• Complex (Fortran)
• Rational (Scheme)

Copyright © 2006 Addison-Wesley. All rights reserved. 1-12

Character Strings

• Values are sequences of characters

• Operations:
– Assignment and copying
– Comparison (=, >, etc.)
– Catenation
– Substring reference
– Pattern matching
• Design issues:
– Is it a primitive type or just a special kind of array?
– Should the length of strings be static or dynamic?

Copyright © 2006 Addison-Wesley. All rights reserved. 1-13

Character String Implementations

• C and C++
– Not primitive
– Use char arrays and a library of functions that
provide operations
• SNOBOL4 (a string manipulation language)
– Primitive
– Many operations, including elaborate pattern
matching
• Java
– String class

Copyright © 2006 Addison-Wesley. All rights reserved. 1-14

Character String Length Options

• Static: COBOL, Java’s String class

• Limited Dynamic Length: C and C++
– In C-based language, a special character is used
to indicate the end of a string’s characters,
rather than maintaining the length
• Dynamic (no maximum): SNOBOL4, Perl,
JavaScript
• Ada supports all three string length options

Copyright © 2006 Addison-Wesley. All rights reserved. 1-15

Character String Implementation

• Static length: compile-time

descriptor
• Limited dynamic length: may
need a run-time descriptor for
length (but not in C and C++)
• Dynamic length: need run-time
descriptor; allocation/de-
allocation is the biggest
implementation problem

Copyright © 2006 Addison-Wesley. All rights reserved. 1-16

User-Defined Ordinal Types

• An ordinal type is one in which the range of

possible values can be easily associated
with the set of positive integers
• Examples of primitive ordinal types in Java
– integer
– char
– boolean
• User-defined ordinal types
– enumeration types
– subrange types

Copyright © 2006 Addison-Wesley. All rights reserved. 1-17

Enumeration Types

• All possible values, which are named

constants, are provided in the definition
• C example
enum days {mon, tue, wed, thu, fri, sat, sun};
• Design issues
– Is an enumeration constant allowed to appear in
more than one type definition, and if so, how is
the type of an occurrence of that constant
checked?
– Are enumeration values coerced to integer?
– Any other type coerced to an enumeration type?

Copyright © 2006 Addison-Wesley. All rights reserved. 1-18

Enumerated types in C (and C++)
• Use the enum keyword to define an enumerated type
in C
enum weekday {Sunday, Monday, Tuesday,
Wednesday, Thursday, Friday, Saturday};
enum weekday today = Tuesday;
• Using typedef makes the enum type easier to use
typedef enum weekday {Sunday, Monday, Tuesday,
Wednesday, Thursday, Friday, Saturday}
weekday;
weekday today = Tuesday;
• By default, the names in the list are numbered
consecutively from 0.
– You can explicitly assign values
Enum months {January=1, February, …};
• Unless you are happy with the int values, you have to
write code for input and output.
Copyright © 2006 Addison-Wesley. All rights reserved. 1-19
Enumerations in Java 1.5

• An enum is a new class which extends

java.lang.Enum and implements
Comparable
– Get type safety and compile-time checking
– Implicitly public, static and final
– Can use either == or equals to compare
– toString and valueOf are overridden to make
input and output easier

Copyright © 2006 Addison-Wesley. All rights reserved. 1-20

Java enum Example

• Defining an enum type

enum Season {WINTER, SPRING, SUMMER, FALL};
• Declaring an enum variable
Season season = Season.WINTER;
• toString gives you the string representation
of the name
System.out.println( season);
// prints WINTER
• valueOf lets you convert a String to an
enum
Season season = valueOf(“SPRING”);
Copyright © 2006 Addison-Wesley. All rights reserved. 1-21
Subrange Types

• An ordered contiguous subsequence of an

ordinal type
– Example: 12..18 is a subrange of integer type
• Ada’s design
type Days is (mon, tue, wed, thu, fri, sat, sun);
subtype Weekdays is Days range mon..fri;
subtype Index is Integer range 1..100;

Day1: Days;
Day2: Weekday;
Day2 := Day1;

Copyright © 2006 Addison-Wesley. All rights reserved. 1-22

Implementation of User-Defined
Ordinal Types

• Enumeration types are implemented as

integers
• Subrange types are implemented like the
parent types with code inserted (by the
compiler) to restrict assignments to
subrange variables

Copyright © 2006 Addison-Wesley. All rights reserved. 1-23

Pointer and Reference Types

• A pointer type variable has a range of

values that consists of memory addresses
and a special value, nil
• Provide the power of indirect addressing
• Provide a way to manage dynamic memory
• A pointer can be used to access a location
in the area where storage is dynamically
created (usually called a heap)
• Generally represented as a single number

Copyright © 2006 Addison-Wesley. All rights reserved. 1-24

Pointer Operations

• Two fundamental operations: assignment

and dereferencing
• Assignment is used to set a pointer
variable’s value to some useful address
• Dereferencing yields the value stored at the
location represented by the pointer’s value
– Dereferencing can be explicit or implicit
– C++ uses an explicit operation via *
j = *ptr
sets j to the value located at ptr

Copyright © 2006 Addison-Wesley. All rights reserved. 1-25

 Pointer Operations Illustrated

assignment operation Dereferencing a pointer

ptr = &j j = *ptr

ptr = (int*)malloc(

sizeof( int))

Copyright © 2006 Addison-Wesley. All rights reserved. 1-26

Problems with Pointers
• Dangling pointers
(dangerous)
– A pointer points to
a heap-dynamic
variable that has
been de-allocated
• Garbage
– An allocated heap-
dynamic variable
that is no longer
accessible to the
user program

Copyright © 2006 Addison-Wesley. All rights reserved. 1-27

Pointers in C and C++

• Extremely flexible but must be used with care

• Pointers can point at any variable regardless of
when it was allocated
• Used for dynamic storage management and
addressing
• Pointer arithmetic is possible
• Explicit dereferencing and address-of operators
• Domain type need not be fixed (void *)
• void * can point to any type and can be type
checked (cannot be de-referenced)

Copyright © 2006 Addison-Wesley. All rights reserved. 1-28

Pointer Arithmetic in C and C++

float stuff[100];
float *p;
p = stuff;

*(p+5) is equivalent to stuff[5] and p[5]

*(p+i) is equivalent to stuff[i] and p[i]

Copyright © 2006 Addison-Wesley. All rights reserved. 1-29

Reference Types

• C++ includes a special kind of pointer type

called a reference type that is used
primarily for formal parameters
– Advantages of both pass-by-reference and
pass-by-value
• Java extends C++’s reference variables and
allows them to replace pointers entirely
– References refer to call instances
• C# includes both the references of Java and
the pointers of C++
Copyright © 2006 Addison-Wesley. All rights reserved. 1-30
Evaluation of Pointers

• Dangling pointers and dangling objects are

problems as is heap management
• Pointers are like goto's--they widen the
range of cells that can be accessed by a
variable
• Pointers or references are necessary for
dynamic data structures--so we can't
design a language without them

Copyright © 2006 Addison-Wesley. All rights reserved. 1-31

Structured Data Types

• Arrays
– An aggregate of homogeneous data elements in
which an individual element is identified by its
position in the aggregate, relative to the first
element.
• Associative arrays
– an unordered collection of data elements that are
indexed by an equal number of values called keys
• Records
– A possibly heterogeneous aggregate of data
elements in which the individual elements are
identified by names
Copyright © 2006 Addison-Wesley. All rights reserved. 1-32
Array Types

• Operations:
– Whole array operations:
• assignment
• catenation
– elemental operations (between pairs of array
elements)
• arithmetic
– Indexing (or subscripting) is a mapping from
indices to elements
array_name (index_value_list)  an element

Copyright © 2006 Addison-Wesley. All rights reserved. 1-33

Array Design Issues

• What types are legal for subscripts? Are

subscripting expressions in element
references range checked?
• When are subscript ranges bound?
• When does allocation take place?
• What is the maximum number of
subscripts?
• Can array objects be initialized?
• Are any kind of slices allowed?

Copyright © 2006 Addison-Wesley. All rights reserved. 1-34

Subscript Binding and Array Categories

• Static: subscript ranges are statically bound and

storage allocation is static (static C and C++ arrays)
• Fixed stack-dynamic: subscript ranges are statically
bound, but the allocation is done at declaration time
(C, C++)
• Stack-dynamic: subscript ranges are dynamically
bound and the storage allocation is dynamic (done at
run-time)
• Fixed heap-dynamic: similar to fixed stack-dynamic:
storage binding is dynamic but fixed after allocation
(Java, C and C++)
• Heap-dynamic: binding of subscript ranges and
storage allocation is dynamic and can change any
number of times (Perl and JavaScript)
Copyright © 2006 Addison-Wesley. All rights reserved. 1-35
Array Initialization

• Some language allow initialization at the

time of storage allocation
– C, C++, Java, C# example
int list [] = {4, 5, 7, 83}
– Character strings in C and C++
char name [] = “freddie”;
– Arrays of strings in C and C++
char *names [] = {“Bob”, “Jake”, “Joe”];
– Java initialization of String objects
String[] names = {“Bob”, “Jake”, “Joe”};

Copyright © 2006 Addison-Wesley. All rights reserved. 1-36

Rectangular and Jagged Arrays

• A rectangular array is a multi-dimensioned

array in which all of the rows have the same
number of elements and all columns have
the same number of elements
• A jagged matrix has rows with varying
number of elements
– Possible when multi-dimensioned arrays
actually appear as arrays of arrays

Copyright © 2006 Addison-Wesley. All rights reserved. 1-37

Slices

• A slice is some substructure of an array;

nothing more than a referencing mechanism
• Slices are only useful in languages that have
array operations
– Java allows row slices from 2D arrays
– Fortran 95
Integer, Dimension (10) :: Vector
Integer, Dimension (3, 3) :: Mat
Integer, Dimension (3, 3) :: Cube

Vector (3:6) is a four element array

Copyright © 2006 Addison-Wesley. All rights reserved. 1-38
Slices Examples in Fortran 95

Copyright © 2006 Addison-Wesley. All rights reserved. 1-39

Implementation of Arrays

• Access function maps subscript expressions

to an address in the array
• Access function for single-dimensioned
arrays:
address(list[k]) = address (list[lower_bound])
+ ((k-lower_bound) * element_size)
• Two common ways to organize 2D arrays
– Row major order (by rows) – used in most
languages
– Column major order (by columns) – used in
Fortran
Copyright © 2006 Addison-Wesley. All rights reserved. 1-40
 Row-major access formula

Location (a[I,j])
= address of a [row_lb,col_lb]
+ (((I - row_lb) * n) + (j - col_lb)) *element_size

Copyright © 2006 Addison-Wesley. All rights reserved. 1-41

Compile-Time Descriptors

Single-dimensioned array Multi-dimensional array

Copyright © 2006 Addison-Wesley. All rights reserved. 1-42

Associative Arrays in Perl

• Names begin with %; literals are delimited

by parentheses
%hi_temps = ("Mon" => 77, "Tue" => 79,
“Wed” => 65, …);
• Subscripting is done using braces and keys
$hi_temps{"Wed"} = 83;
– Elements can be removed with delete
delete $hi_temps{"Tue"};

Copyright © 2006 Addison-Wesley. All rights reserved. 1-43

Operations on Records

• Assignment is very common if the types are

identical
• Ada allows record comparison
• Ada records can be initialized with
aggregate literals
• COBOL provides MOVE CORRESPONDING
– Copies a field of the source record to the
corresponding field in the target record

Copyright © 2006 Addison-Wesley. All rights reserved. 1-44

Evaluation and Comparison to Arrays

• Straight forward and safe design

• Records are used when collection of data
values is heterogeneous
• Access to array elements is much slower
than access to record fields, because
subscripts are dynamic (field names are
static)
• Dynamic subscripts could be used with
record field access, but it would disallow
type checking and it would be much slower

Copyright © 2006 Addison-Wesley. All rights reserved. 1-45

Implementation of Record Type

Offset address relative to

the beginning of the records
is associated with each field

Copyright © 2006 Addison-Wesley. All rights reserved. 1-46

Union Types

• A union is a type whose variables are allowed

to store different type values at different times
during execution
• Fortran, C, and C++ provide union constructs
in which there is no language support for type
checking; the union in these languages is
called free union
• Type checking of unions require that each
union include a type indicator called a
discriminant
– Supported by Ada

Copyright © 2006 Addison-Wesley. All rights reserved. 1-47

Evaluation of Unions

• Potentially unsafe construct

– Do not allow type checking
• Java and C# do not support unions
– Reflective of growing concerns for safety in
programming language

Copyright © 2006 Addison-Wesley. All rights reserved. 1-48