Data Types

Copyright © 2009 Addison-Wesley. All rights reserved. 1-1

Chapter 6 Topics

• Introduction
• Primitive Data Types
• Character String Types
• User-Defined Ordinal Types
• Array Types
• Associative Arrays
• Record Types
• Union Types
• Pointer and Reference Types

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

Introduction

• 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
• One design issue for all data types: What
operations are defined and how are they
specified?

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

Primitive Data Types

• Almost all programming languages provide

a set of primitive data types
• Primitive data types: Those not defined in
terms of other data types
• Some primitive data types are merely
reflections of the hardware
• Others require only a little non-hardware
support for their implementation

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

Primitive Data Types: Integer

• 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

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

Primitive Data Types: Floating Point

• 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

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

Primitive Data Types: Complex

• Some languages support a complex type,

e.g., C99, Fortran, and Python
• Each value consists of two floats, the real
part and the imaginary part
• Imaginary part is specified by j (in Python):
(7 + 3j), where 7 is the real part and 3 is
the imaginary part

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

Primitive Data Types: Decimal

• For business applications (money)

– Essential to COBOL
– C# offers a decimal data type
• Store a fixed number of decimal digits, in
coded form (BCD)
• Advantage: accuracy
• Disadvantages: limited range, wastes
memory

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

Primitive Data Types: Boolean

• Simplest of all
• Range of values: two elements, one for
“true” and one for “false”
• Could be implemented as bits, but often as
bytes
– Advantage: readability

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

Primitive Data Types: Character

• Stored as numeric codings

• Most commonly used coding: ASCII
• An alternative, 16-bit coding: Unicode
(UCS-2)
– Includes characters from most natural
languages
– Originally used in Java
– C# and JavaScript also support Unicode
• 32-bit Unicode (UCS-4)
– Supported by Fortran, starting with 2003
Copyright © 2009 Addison-Wesley. All rights reserved. 1-10
Character String Types

• Values are sequences of characters

• Design issues:
– Is it a primitive type or just a special kind of
array?
– Should the length of strings be static or
dynamic?

Copyright © 2009 Addison-Wesley. All rights reserved. 1-11

Character String Types Operations

• Typical operations:
– Assignment and copying
– Comparison (=, >, etc.)
– Catenation
– Substring reference
– Pattern matching

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

Character String Type in Certain
Languages
• C and C++
– Not primitive
– Use char arrays and a library of functions that provide
operations
• Fortran and Python
– Primitive type with assignment and several operations
• Java
– Primitive via the String class
• Perl, JavaScript, Ruby, and PHP
- Provide built-in pattern matching.

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

Character String Length Options

• Static: COBOL, Java’s String class

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

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

Character String Type Evaluation

• Aid to writability
• As a primitive type with static length, they
are inexpensive to provide--why not have
them?
• Dynamic length is nice, but is it worth the
expense?

Copyright © 2009 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 © 2009 Addison-Wesley. All rights reserved. 1-16

Compile- and Run-Time Descriptors

Compile-time Run-time
descriptor for descriptor for
static strings limited dynamic
strings
Copyright © 2009 Addison-Wesley. All rights reserved. 1-17
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

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

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 © 2009 Addison-Wesley. All rights reserved. 1-19

Evaluation of Enumerated Type

• Aid to readability, e.g., no need to code a

color as a number
• Aid to reliability, e.g., compiler can check:
– operations (don’t allow colors to be added)
– No enumeration variable can be assigned a
value outside its defined range
– Ada, C#, and Java 5.0 provide better support for
enumeration than C++ because enumeration
type variables in these languages are not
coerced into integer types

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

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: Weekdays;
Day2 := Day1;

Copyright © 2009 Addison-Wesley. All rights reserved. 1-21

Subrange Evaluation

• Aid to readability
– Make it clear to the readers that variables of
subrange can store only certain range of values
• Reliability
– Assigning a value to a subrange variable that is
outside the specified range is detected as an
error

Copyright © 2009 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 © 2009 Addison-Wesley. All rights reserved. 1-23

Array Types

• An array is an aggregate of homogeneous

data elements in which an individual
element is identified by its position in the
aggregate, relative to the first element.

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

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 supported?

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

Array Indexing

• Indexing (or subscripting) is a mapping

from indices to elements
array_name (index_value_list)  an element
• Index Syntax
– FORTRAN, PL/I, Ada use parentheses
• Ada explicitly uses parentheses to show uniformity
between array references and function calls because
both are mappings
– Most other languages use brackets

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

Arrays Index (Subscript) Types

• FORTRAN, C: integer only

• Ada: allows other types such as Boolean, char, and
enumeration
• Java: integer types only
• Index range checking
- C, C++, Perl, and Fortran do not specify
range checking
- Java, ML, C# specify range checking
- In Ada, the default is to require range
checking, but it can be turned off

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

Subscript Binding and Array Categories

• Static: subscript ranges are statically bound

and storage allocation is static (before run-
time)
– Advantage: efficiency (no dynamic allocation)
• Fixed stack-dynamic: subscript ranges are
statically bound, but the allocation is done
at declaration time
– Advantage: space efficiency

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

Subscript Binding and Array Categories
(continued)

• Stack-dynamic: subscript ranges are

dynamically bound and the storage
allocation is dynamic (done at run-time)
– Advantage: flexibility (the size of an array need
not be known until the array is to be used)
• Fixed heap-dynamic: similar to fixed stack-
dynamic: storage binding is dynamic but
fixed after allocation (i.e., binding is done
when requested and storage is allocated
from heap, not stack)

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

Subscript Binding and Array Categories
(continued)

• Heap-dynamic: binding of subscript ranges

and storage allocation is dynamic and can
change any number of times
– Advantage: flexibility (arrays can grow or shrink
during program execution)

Copyright © 2009 Addison-Wesley. All rights reserved. 1-30

Subscript Binding and Array Categories
(continued)
• C and C++ arrays that include static
modifier are static
• C and C++ arrays without static modifier
are fixed stack-dynamic
• C and C++ provide fixed heap-dynamic
arrays
• C# provides fixed heap-dynamic
• Perl, JavaScript, Python, and Ruby support
heap-dynamic arrays

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

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 © 2009 Addison-Wesley. All rights reserved. 1-32

Heterogeneous Arrays

• A heterogeneous array is one in which the

elements need not be of the same type
• Supported by Perl, Python, JavaScript, and
Ruby

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

Arrays Operations
• The most common array operations are
Assignment
Catenation
Comparison for equality and Inequality
Slices
• Ada and Python’s allow array assignment and
catenation
• Ruby also provides array catenation
• Fortran provides elemental operations because
they are between pairs of array elements
– For example, + operator between two arrays results in an
array of the sums of the element pairs of the two arrays

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

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
• C, C++, and Java support jagged arrays
• Fortran, Ada, and C# support rectangular
arrays (C# also supports jagged arrays)
Copyright © 2009 Addison-Wesley. All rights reserved. 1-35
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

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

Slice Examples

• Consider the following Python declarations:

vector = [2, 4, 6, 8, 10, 12, 14, 16]
mat = [[1, 2, 3],[4, 5, 6],[7, 8, 9]]
• vector[3:6] is a three-element array
• mat[1] refers to the second row of mat
• mat[0][0:2] refers to the first and second
element of the first row of mat
• vector[0:7:2] references every other
element of vector

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

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)

Copyright © 2009 Addison-Wesley. All rights reserved. 1-38

 Accessing Multi-dimensioned Arrays

• Two common ways:

– Row major order (by rows) – used in most languages
– column major order (by columns) – used in Fortran
Example,
347
625
138

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

Associative Arrays

• An associative array is an unordered

collection of data elements that are
indexed by an equal number of values
called keys
– User-defined keys must be stored
• Design issues:
- What is the form of references to elements?
- Is the size static or dynamic?
• Supported by Perl, Python, Ruby, and Lua

Copyright © 2009 Addison-Wesley. All rights reserved. 1-40

Associative Arrays in Perl

• Names begin with %; elements are

delimited by a comma
%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 © 2009 Addison-Wesley. All rights reserved. 1-41

Record Types

• A record is a possibly heterogeneous

aggregate of data elements in which the
individual elements are identified by names
• Design issues:
– What is the syntactic form of references to the
field?
– Are elliptical references allowed

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

Definition of Records in COBOL

• COBOL uses level numbers to show nested

records; others use recursive definition
01 EMP-REC.
02 EMP-NAME.
05 FIRST PIC X(20).
05 MID PIC X(10).
05 LAST PIC X(20).
02 HOURLY-RATE PIC 99V99.

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

Definition of Records in Ada
• Records must be named types
type Emp_Name_Type is record
First: String (1..20);
Mid: String (1..10);
Last: String (1..20);
end record;
Type Emp_Rec_Type is record
Emp_Name: Emp_Name_Type;
Hourly_Rate: Float;
end record;
Copyright © 2009 Addison-Wesley. All rights reserved. 1-44
References to Records
• Record field references
1. COBOL
field_name OF record_name_1 OF ... OF record_name_n
2. Others (dot notation)
record_name_1.record_name_2. ... record_name_n.field_name

• Fully qualified references must include all record names

• Elliptical references allow leaving out record names as long

as the reference is unambiguous, for example in COBOL
FIRST, FIRST OF EMP-NAME, and FIRST of EMP-REC are
elliptical references to the employee’s first name

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

Operations on Records

• Assignment is very common if the types are

identical
• Ada allows record comparison
• COBOL provides MOVE CORRESPONDING
– Copies a field of the source record to the
corresponding field in the target record

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

Evaluation and Comparison to Arrays

• 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 © 2009 Addison-Wesley. All rights reserved. 1-47

Implementation of Record Type

Offset address relative to

the beginning of the records
is associated with each field

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

Unions Types

• A union is a type whose variables are

allowed to store different type values at
different times during execution
• Design issues
– Should type checking be required?
– Should unions be embedded in records?

Copyright © 2009 Addison-Wesley. All rights reserved. 1-49

Discriminated vs. Free Unions

• 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 © 2009 Addison-Wesley. All rights reserved. 1-50

Evaluation of Unions

• Free unions are unsafe

– Do not allow type checking
• Java and C# do not support unions
– Reflective of growing concerns for safety in
programming language
• Ada’s descriminated unions are safe

Copyright © 2009 Addison-Wesley. All rights reserved. 1-51

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.

Copyright © 2009 Addison-Wesley. All rights reserved. 1-52

Design Issues of Pointers

• What are the scope of and lifetime of a

pointer variable?
• What is the lifetime of a data pointed by a
pointer?
• Can a pointer points to different data type?
• Are pointers used for dynamic storage
management, indirect addressing, or both?
• Should the language support pointer types,
reference types, or both?

Copyright © 2009 Addison-Wesley. All rights reserved. 1-53

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 © 2009 Addison-Wesley. All rights reserved. 1-54

Pointer Assignment Illustrated

The assignment operation j = *ptr

Copyright © 2009 Addison-Wesley. All rights reserved. 1-55

Problems with Pointers

• Dangling pointers (dangerous)

– A pointer points to a heap-dynamic variable that has been
deallocated
• Lost heap-dynamic variable
– An allocated heap-dynamic variable that is no longer
accessible to the user program (often called garbage)
• Pointer p1 is set to point to a newly created heap-
dynamic variable
• Pointer p1 is later set to point to another newly created
heap-dynamic variable
• The process of losing heap-dynamic variables is called
memory leakage

Copyright © 2009 Addison-Wesley. All rights reserved. 1-56

Pointers in Ada

• Some dangling pointers are disallowed

because dynamic objects can be
automatically deallocated at the end of
pointer's type scope
• The lost heap-dynamic variable problem is
not eliminated by Ada

Copyright © 2009 Addison-Wesley. All rights reserved. 1-57

Pointers in C and C++

• Extremely flexible but must be used with care

• Pointers can point at any variable regardless of
when or where 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 © 2009 Addison-Wesley. All rights reserved. 1-58

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 © 2009 Addison-Wesley. All rights reserved. 1-59

Reference Types

• C++ includes a special kind of pointer type

called a reference type that is used to refer
to an object in memory
• Reference type are preceded by &
• Example: float &result
• Java extends C++’s reference variables and
allows them to replace pointers entirely
– References are references to objects, rather than
being addresses
• C# includes both the references of Java and
the pointers of C++
Copyright © 2009 Addison-Wesley. All rights reserved. 1-60
Evaluation of Pointers

• Dangling pointers and dangling objects are

problems
• Pointers or references are necessary for
dynamic data structures--so we can't
design a language without them

Copyright © 2009 Addison-Wesley. All rights reserved. 1-61

Dangling Pointer Problem

• Tombstone: extra heap cell that is a pointer to the

heap-dynamic variable
– The actual pointer variable points only at tombstones
– When heap-dynamic variable de-allocated, tombstone
remains but set to nil
– Costly in time and space
. Locks-and-keys: Pointer values are represented as
(key, address) pairs
– Heap-dynamic variables are represented as variable plus
cell for integer lock value
– The key is compared to the lock to verify whether the
storage can be accessed or not

Copyright © 2009 Addison-Wesley. All rights reserved. 1-62

Dangling Pointer Problem
(Tombstone)

Copyright © 2009 Addison-Wesley. All rights reserved. 1-63

Heap Management

• Two approaches are available – reference count

and garbage collection.
– Reference count keeps a reference count for every data
block that is pointed by pointers.
– Garbage collection marks the storage in use and reclaim
those that are not.
• Reference count approach wastes storage for the
counts, has overhead in handling the counts, and
could not handle cycles of memory that should be
reclaimed.
• Garbage collection marks the blocks that are
referenced by pointers then reclaim those blocks
that are not marked.
Copyright © 2009 Addison-Wesley. All rights reserved. 1-64
Type Checking

• Type checking is the activity of ensuring that the operands of

an operator are of compatible types

• A compatible type is one that is either legal for the operator,

or is allowed under language rules to be implicitly converted,
by compiler- generated code, to a legal type
– This automatic conversion is called a coercion.

• A type error is the application of an operator to an operand

of an inappropriate type

Copyright © 2009 Addison-Wesley. All rights reserved. 1-65

Type Checking (continued)

• If all type bindings are static, nearly all type

checking can be static
• If type bindings are dynamic, type checking
must be dynamic
• A programming language is strongly typed
if type errors are always detected
• Advantage of strong typing: allows the
detection of the misuses of variables that
result in type errors

Copyright © 2009 Addison-Wesley. All rights reserved. 1-66

Strong Typing

Language examples:
– C and C++ are not: parameter type checking
can be avoided; unions are not type checked
– Ada is nearly strongly typed.(programmer can
suspend type checking)
(Java and C# are similar to Ada)

Copyright © 2009 Addison-Wesley. All rights reserved. 1-67

Summary

• The data types of a language are a large part of

what determines that language’s style and
usefulness
• The primitive data types of most imperative
languages include numeric, character, and Boolean
types
• The user-defined enumeration and subrange types
are convenient and add to the readability and
reliability of programs
• Arrays and records are included in most languages
• Pointers are used for addressing flexibility and to
control dynamic storage management

Copyright © 2009 Addison-Wesley. All rights reserved. 1-68