Data Types

• Programming languages need a variety of data types in

order to better model/match the world
– more data types make programming easier but too many data
types might be confusing
• which data types are most common?
• which data types are necessary?
• which data types are uncommon yet useful?
– how are data types implemented in the various languages?
• Almost all programming languages provide a set of
primitive data types
– primitive data types are those not defined in terms of other data
types
– some primitive data types are implemented directly in hardware
(integers, floating point, etc) while others require some non-
hardware support for their implementation such as arrays
 Language Support of Data Types
• Historically, we see the following:
– FORTRAN only had numeric types and arrays
– COBOL introduced advanced record structures, character
strings and decimal
– Lisp had built-in linked lists
– PL/I was the first language to offer a wide range of types but
did not allow for tailor-made types
– ALGOL 68 took a different approach by offering few types
but these types were combinable into many advanced types
• strings = arrays + chars
• lists, trees, queues, stacks, graphs, sets = records + pointers or arrays
• Most languages since ALGOL have adopted ALGOL’s
approach – few basic types that are used to define a
greater variety
– later on, the notion of abstract data types and even later,
object-oriented programming, expanded on these ideas
 Primitive Data Types
• Types supported directly in hardware of the machine
– Integer: byte, short, int, long, signed, unsigned
– Floating Point: single and double precision
• stored in 3 parts: sign bit, exponent, mantissa
– Complex: numbers that contain an imaginary part
• available in languages like Common Lisp, FORTRAN and Python
– Decimal: BCD (2 decimal digits per byte)
• for business processing whereby numbers (dollars and cents) are
stored as 1 digit per ½ byte instead of using an int format
• popularized in COBOL, also used in PL/I and C#
– Boolean: 1-bit value (usually referenced as true or false)
• available in C++, Java, Pascal, Ada, Lisp, but not C
• in Lisp, the values are T or NIL
• for hardware convenience, these are often stored in 1 byte or 1 word!
– Character: ASCII or Unicode
• IBM mainframes use a different code called EBCDIC
• Java, Javascript C# support Unicode
 Types Found in PL/I
• We briefly look at PL/I types because of the wide range and depth
– Numeric types:
• Fixed decimal (like BCD, with specified length and decimal point)
• Fixed binary (same but values specified in binary)
• Float decimal/binary (true floating point, including integers)
• Zoned decimal (any form of number used for output to files)
• Complex
– Non-numeric types:
• Character, Bit, Pointers, Builtin – when requesting a piece of built-in
information such as calling the function DATE or TIME
– Structures:
• Strings indicated by number of Characters, “varying” means any length up to a
specified maximum as in DCL NAME CHAR(20) VARYING;
• Records – declared much like COBOL records
• Pictures –like COBOL: specified char-by-char (Z, V, 0, 9, .)
• Files
• Lists – circular and bidirectional available
• Binary Tree
• Stack
 Character Strings
• Should a string be a primitive type or defined as an array of chars?
– few languages offer them as primitives (SNOBOL does)
– in most languages, they are arrays of chars (Pascal, Ada, C/C++)
– Java/C# offer them as objects
• Design issues:
– should strings have static or dynamic length?
– can they be accessed using indices (like arrays)?
• this is true if the string is treated as an array
– what operations should be available on strings?
• assignment, <, =, >, concat, substring
– available in Pascal/Ada only if declared as packed arrays
– available through libraries in C/C++ and through built-in objects in Java/C#
• Character string types could be supported directly in hardware, but
in most cases, software implements them as arrays of chars
– so the questions are:
• how are the various operations implemented
– as library routines/class methods or directly in the language?
• how is string length handled?
 Implementing Strings
• Three forms of string lengths:
– Static length strings – string size is set when the string is created
• this is the case with FORTRAN 77/90, COBOL, C#, C++ and Java
• if the string is an object as is the case in Java, and possibly in C#/C++, strings are
immutable
– Limited dynamic length strings – string lengths can vary up to a specified
limit, for instance, if we declare the string to be 50, it can hold up to 50 chars
• this is the case with Pascal, C, C++, PL/I
– Dynamic length strings – strings can change length at any time with no
maximum restriction
• this is the case with SNOBOL, LISP, JavaScript, Perl
• strings might be stored in a linked list, or as an array from heap memory which
needs a lot of memory movement as the string grows
• Most languages generate a descriptor for every compiled string

The dynamic string requires dynamic

memory but only uses a single current
length field for the length
 Ordinal Types
• Ordinal: countable, or where the items have an ordering
• Does the language provide a facility for programmers to define ordinals?
– ordinal types can promote readability
– programmers provide symbolic constants (names)
– often used in for-loops and switch statements
• Languages which support Ordinal types:
– C and Pascal were the first two languages to offer this, C++ cleaned up C’s enum
type
– Pascal includes operations PRED, SUCC, ORD
– C/C++ permit ++ and --
– in C#, enum types are not treated as ints
– Java does not include ordinals but can be simulated through proper class definitions
– FORTRAN 77 can simulate enums through constants
• Another form of user-defined ordinal type is the subrange
– limited range of a previously defined ordinal type
– introduced in Pascal and made available in Ada
– for example: use .. to indicate the subrange as in 0..5
– subranges require compile-time type checking and run-time range-checking
– subranges have not been made available in the C-like languages
 Array Types
• Arrays are homogenous aggregate data elements
– design issues include:
• what types are legal for subscripts?
• when are subscript ranges bound?
• when does array allocation take place?
• how many subscripts are allowed? is there a limit to array dimensions?
• are multi-dimensional arrays rectangular or are ragged arrays allowed?
• can arrays be initialized at allocation time?
• are slices allowed?
• Array dimensions:
– FORTRAN I - limited to 3, FORTRAN IV and onward - up to 7
– most other languages have no restriction on array dimensions
• C/C++/Java - arrays are limited to 1 dimension only but arrays can be nested
• this is actually an array of pointers so that you can have as many dimensions as
you want
• because the pointers might point to different sized arrays, this can lead to jagged
arrays
• most languages restrict you to rectangular arrays (the number of elements for
each row are the same)
– C# supports both rectangular and jagged arrays
 Indexes
• Index maps array element to memory location
– early languages did no run-time range checking, but range-checking is done
in most modern languages for reliability
• Array indexes are usually placed in some syntactic unit
– [ ] in most languages: Pascal, Modula-2, C-languages
– ( ) in FORTRAN, PL/I, Ada
• parens weaken readability because something like foo(x) is now hard to read – is
it a subroutine call or an array access?
– Lisp uses a function as in (aref array 6) to mean array[6]
• Most languages separate dimensions by ,
– but C-languages use [ ][ ]
• Two types associated with arrays that need to be declared
– the type of value being stored
– the type of value used for an index (in Pascal-like languages)
• Are lower bounds automatically set?
– C/C++, Java, early FORTRAN use 0
– 1 is used in later FORTRANs
– explicit in all other languages
 Array Subscript Categories
• When is the subscript range bound? That is, when is
the decision on the size of the array made?
– Static
• subscript range bound before run-time (compile, link or load-time)
• most efficient but most restrictive, the array is fixed in size
• FORTRAN I – 77, C/C++ if declared with the word static
– Fixed Stack-Dynamic
• subscript range is bound at compile time but allocation of the array
occurs at run-time from the run-time stack – array size determined
when function called
• Ada, Basic, C, C++, Pascal, Java, FORTRAN 90
– Stack-Dynamic
• subscript range dynamically bound and dynamically allocated but
remains fixed for lifetime of the array – this allows the array size to be
determined at run-time for more efficient space-usage
• Ada if specifically declared this way, ALGOL-60 arrays
 Language Examples
• Fixed Heap-dynamic
– like fixed stack-dynamic except that memory comes from the heap, not the
stack, so the size and memory is dynamically allocated, but size is static
once created
– C/C++ if allocated using malloc or calloc
– all arrays in Java and C# since they are objects and all objects are allocated
from the heap
– FORTRAN 90 and 95
• Heap-Dynamic
– dynamically bound and allocated, and changeable during array’s lifetime –
the most flexible type of array as it can permit the array to grow or shrink
as needed during run-time
– Perl, JavaScript, Lisp
– C# if declared as an object of type ArrayList
– ALGOL-60 could simulate heap-dynamic using the flex command
– Java and C# can simulate heap-dynamic through array copying
 Array Initialization and Operations
• Initialization
– FORTRAN 77 offers optional initialization at allocation time (load time)
– C/C++/Java offer optional initialization that can also dictate array size and
through initializations, you can create jagged arrays
– in Ada, specific elements can be specified rather than initializing the entire
array
– for Pascal, Modula-2, no array initializations
– most languages permit only initialization and access to a single element
• Assignment
– Ada, Pascal allow entire array assignment if the arrays are of the same
type/size
• Ada also has array concatenation
– in C/C++/Java, assignment is copying a pointer, not duplicating the array
– FORTRAN 95 includes a variety of array operations
• such as +, relational operations (comparisons), matrix multiplication and
transpose, etc (all through library routines)
– APL includes a collection of vector and matrix operations
 Slices
• Definable substructure of an array
– e.g., a row of a 2 D array or a plane of a 3-D array
• In FORTRAN:
– Integer Vector(1:10), Matrix(1:10, 1:20)
• Vector(3:6) defines a subarray of 4 elements in Vector
• : by itself is used to denote “wild card” (all elements) in FORTRAN 95 so
Matrix(1:5, :) means half of the first dimension and all of the second
• FORTRAN 90 & 95 have very complex Slice features such as
skipping every other location
– slices can be used to initialize arrays that are different in size and
dimension
• for instance, initializing a 1-D array to be the first row of a 2-D array
– slice references can appear on either the left or right hand side of an
assignment statement
• Ada restricts slices to consecutive memory locations within a
dimension of an array for instance, a part of a row
• Python provides mechanisms for slices of tuples
– recall Python does not have arrays, instead it has this list-like constructs
that can be heterogeneous
 Array Implementations
• Arrays are almost always a contiguous block of memory equal to
the size needed to store the array
– each successive array element is stored in the next memory location
• We define a mapping function which translates the array indexes
to the memory location, for instance a 1-D array in C maps as
– a[i] = OFFSET + i * length
• OFFSET is the starting point of the array and length is the size in bytes of
each element
• if the language has a lower bound of 1, then we change the above to be (i – 1)
• Multi-dimensional arrays in C-languages are altered to include
the memory used by all previous rows:
a[i][j] = OFFSET + i * n * length + j * length

That is, the array element at [i, j] has i previous rows of n

(including row 0) items each, and j elements in the current row

More generically, for languages that allow for a non-0 lower

bound, we would use a[i, j] = OFFSET + (i – loweri) * n *
length + (j – lowerj) * length
 More on Mapping
• Most languages use row-major order
– in row-major order, all of row i is placed consecutively,
followed by all of row i+1, etc.
• FORTRAN is the only common language to instead use column-major
order.
– we don’t have to know whether a language uses row-major or
column-major order when writing our code
• but we could potentially write more efficient code when dealing with
memory management and pointer arithmetic if we did know
• With multi-dimensional arrays (beyond 2), the mapping
function is just an extension of what we had already seen
– for a 3-d array a[m][n][p], we would use:
• a[i, j, k] = OFFSET + i*n*length + j*m*length + k*length
– this formula will not work if we are dealing with jagged arrays
 Array Descriptors
• As with strings, arrays are commonly implemented by the
compiler generating array descriptors for each array
– these descriptors include all information necessary to generate the
mapping function
– in most languages, both the lower and upper bounds are required, in
C/C++/Java/C#, lower bounds are always 0 and in FORTRAN, they are
always 1

here we have
descriptors for
1-D and multi-D
arrays
 Associative Arrays
• An associative array uses a key to map to the proper
location rather than an index
– keys are user-defined and must be stored in the data structure
itself
– this is basically a hash table
• Associative arrays are available in Java, Perl, and PHP,
and supported in C++ as a class and Python as a type
called a dictionary
– in Perl, associative arrays are implemented using a hash table
and a 32-bit hash value, but, at least initially, only a portion
of the hash value is used and stored, this is increased as
needed if the hash table grows
– in PHP, associative arrays are implemented as linked lists
with a hashing function that can point into the linked list
 Record Types
• Heterogeneous aggregate of
Examples:
data elements
– elements referred to as fields or COBOL (nested structure in one
members definition)
– introduced in COBOL 01 EMPLOYEE-RECORD.
02 EMPLOYEE-NAME.
– incorporated into most
05 FIRST PICTURE IS X(10).
languages since then 05 MIDDLE PICTURE IS X(10).
• Java does not have a record 05 LAST PICTURE IS X(20).
type but uses the class construct 02 HOURLY-RATE PICTURE IS 99V99.
instead
– may be hierarchically structured Ada (nested through multiple definitions)
(nested) type Employee_Name_Type is record
First : String(1..10);
• Design Issues: Middle : String(1..10);
Last : String(1..10);
– how to build hierarchical end record;
structure type Employee_Record is record
– referencing of fields Employee_Name : Employee_Name_Type
Hourly_Rate : Float;
– record operations and end record;
implementations
 Record Operations
• Assignment
– if both records are the same type
– allowed in Pascal, Ada, Modula-2, C/C++
• Comparison (Ada)
• Initialization (Ada, C/C++)
• Move Corresponding (COBOL)
– copies input record to output file while possibly performing some
modification
• To reference an individual element:
– COBOL uses OF as in First OF Emp-Name
– Ada uses “.” as in Emp_Rec.Emp_Name.First
– Pascal, Modula-2 same as Ada but also allow a With statement so that
variable names can be omitted
• with emp_record do
– begin
– first = …
– end;
– FORTRAN 90/95 use % sign as in Emp_Rec%Emp_Name%First
– PL/I and COBOL allow elliptical references where you only specify the
field name if the name is unambiguous
 Record Implementation
• Similar to Arrays, requires a mapping function
– since fields are statically defined, mapping function is determined at
compile-time
– example:
A generic
type Foo is record compile-time
name : String(1..10); descriptor for
sex : char; a record is
salary : float; given to the right
end record;

If a variable, x, of type Foo starts at offset, then

x.name = offset
x.sex = offset + 10
x.salary = offset + 11

If we have an array a of Foo starting at index 0, then

a[i].name = offset + 12 * i
a[i].sex = offset + 12 * i + 10
a[i].salary = offset + 12 * i + 11
 Union Types
• Types which can store different types of variables at different
times of execution
– FORTRAN’s Equivalence instruction:
• Integer X Real Y Equivalence (X, Y)
• declares one memory location for both X and Y
– the Equivalence statement is not a type, it just commands the compiler to share
the same memory location
• in FORTRAN, there is no mechanism for the program to determine whether
X or Y is currently stored in that location and so no type checking can be
done
• Other languages have union types
– the type defines 1 location for two variables of different types
– design issues:
• should type checking be required? If so, this must be dynamic type checking
• can unions be embedded in records?
 Union Examples
• A Free Union is a union in which no type checking is
performed
– this is the case with FORTRAN’s Equivalence, and with
C/C++ union construct
• A Discriminating Union is a union in which a tag (also
called a discriminant) is added to the memory location
to determine which type is currently being stored
– ALGOL 68 introduced this idea and it is supported in Ada
– in ALGOL 68:
• UNION(int, real) ir1, ir2
– ir1 and ir2 share the same memory location which stores an
int if it is currently ir1, and a real if it is currently ir2
– union (int, real) ir1;
int count;
ir1 := 33;
count := ir1; (this statement is not legal)
 Variant Records
• In Pascal, Ada, and Modula-2, another type of Union is
available called the Variant Records
– in this case, the fields of a record are variable depending on
the type of specific record
– here is a definition for a variant record in Pascal and the
memory reserved for it:

type shape=(circle, triangle,rectangle);

type colors = (red, green, blue);
object = record
filled : boolean;
color : colors;
case form : shape of
circle : (diameter : real);
rectangle : (side1, side2 : integer);
triangle : (leftside, rightside : integer; angle : real);
end;
 Problems with Union Types
• If the user program can modify the discriminant (tag), then
the value(s) stored there are no longer what was expected
– for instance, consider changing the discriminant of our previous
shape from triangle to rectangle, then the values of side1 and
side2 are actually the old values of leftside and rightside, which
are meaningless
• Free unions are not type checked
– this gives the programmer flexibility but reduces reliability
• Union types (whether free or discriminated) are hard to
read and may not make much sense to those who have not
used them
– Union types continue to be available in many modern languages
so that the language is not strongly typed
• that is, unions are specifically made available to give the programmer a
mechanism to avoid type checking!
 Pointer Types
• Used for indirect addressing for dynamic memory
– dynamic memory when allocated, does not have a name, so these are
unnamed or anonymous variables and can only be accessed through a
pointer
• Pointers store memory locations or null
– usually null is a special value so that pointers can be implemented as
special types of int values
• By making pointers a specific type, some static allocation is
possible
– the pointer itself can be allocated at compile-time, and uses of the
pointer can be type checked at compile-time
• Design issues:
– what is the scope and lifetime of the pointer?
– what is the lifetime of the variable being pointed to?
– are there restrictions on the type that a pointer can point to?
– should the pointer be implemented as a pointer or reference variable?
• Pointer Access
Pointer Operations
– retrieve the memory location stored in the pointer
• if available, this can allow pointer arithmetic (e.g., C)
• Dereferencing
– using a pointer to access the item being pointed to
• Implicit Dereferencing
– dereferencing is done automatically when the pointer is accessed
• used in FORTRAN, ALGOL 68, Lisp, Java, Python
• in more recent languages, the pointer is not even treated (or called) a pointer
because all access is done implicitly, this makes the use of the pointer much
safer although far more restrictive
• Explicit Dereferencing
– explicit command to access what the pointer is pointing too
• C/C++ use * (or -> for structs), Ada uses ., Pascal uses ^
• Explicit Allocation
– used in C/C++ (malloc or new), PL/I (allocate), Pascal (new), etc
• Explicit Deallocation
– used in Ada, PL/I, C, C++, and Pascal but not Java, Lisp or C#
• in many of these languages, while there is a command to deallocate memory, it
is often not implemented so the result is that the pointer still points to memory!
 Pointer Problems
• Type Checking
– if pointers are not restricted as to what they can point to, type checking can
not be done at compile-time
• is it done at run-time (time consuming) or is the language unreliable?
• in C/C++, void * pointers are allowed which can point to any type
– dereferencing requires casting the value to permit some type checking
• Dangling Pointers
– if a pointer is deallocated, then the memory that was being used is now
returned to the heap
– if the pointer still retains the address, then we have a dangling pointer
• that is, the pointer may still be pointed at the deallocated value in memory
• this can lead to accessing something unexpected
• Lost Heap-Dynamic Variables
– allocated memory which no longer has a pointer pointing at it can not be
accessed – if the programmer is responsible for deallocating the memory,
then this could result in heap memory that is not used by is not available
• in Java, C#, and Lisp, such items are automatically garbage collected
• Pointer Arithmetic
– available in C/C++ which can lead to accessing the wrong areas of memory
 Pointers in PLs
• PL/I: first language to use pointers, very flexible which led to
errors
• ALGOL 68: less error due to explicitly declaring referenced type
(type checking) and no explicit deallocation so no dangling
pointers
• Ada: memory can be automatically deallocated at the end of a
block to lessen dangling pointers, but also has explicit deallocation
if more desired
• C/C++: extremely flexible pointers
– often used as a means of indirect addressing similar to assembly
– pointer arithmetic available for convenience in array accessing
• FORTRAN 95: pointers can point to both heap and static variables
but all pointers are required to have a Target attribute to ensure
type checking
• Java & C#: both use implicit pointers (reference types) although
C# also has standard pointers
– C++ also has a reference type although used primarily for formal parameters
in function definitions, which acts as a constant
 Implementing Pointer Types
• Pointers are implemented along with heap management
– the heap is a section of memory that is reserved for program
allocation and deallocation
• pointers themselves are usually 2 or 4-byte int values storing addresses
as offsets into the heap
– to deal with dangling ptrs:
• tombstones are special pointers that denote whether a given pointer’s
memory is still allocated or has been deallocated
• locks and keys are two values stored with the pointer (key) and the
allocated memory (lock)
– if the two values don’t match on an access, then it is a dangling pointer
situation and access is disallowed
– heap management requires the ability to
• allocate memory
• restore the heap upon deallocation (or garbage collection)