CSC204 Chapter 6: Data Types

Introduction to Data Types

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

Primitive Data Types

• Primitive data types are those not defined in terms of other data types.
• Some primitive data types are merely reflections of the hardware, while others require only a little non-hardware support for their implementation.
• Examples of primitive data types include:
  • Integer: a common numeric data type, with signed integer sizes in Java including byte, short, int, and long.
  • Floating-Point: a data type that models real numbers, but only as approximations, represented as fractions and exponents.
  • Boolean: a simple data type with a range of values consisting of two elements, one for "true" and one for "false".
  • Character: a data type stored as numeric coding, with the most commonly used coding being ASCII.

Character String Types

• Character string types are values that are sequences of characters.
• In C and C++, character string types are not primitive, but rather use char arrays and a library of functions that provide operations.
• In Java, character string types are primitive via the String class.
• Typical operations on character string types include:
  • Assignment and copying
  • Comparison (=, >, etc.)
  • Catenation
  • Substring reference
  • Pattern matching
• String length options include:
  • Static: COBOL, Java's String class
  • Limited Dynamic Length: C and C++
  • Dynamic (no maximum): Perl, JavaScript
  • Ada supports all three string length options

Enumeration Types

• Enumeration types are defined by specifying all possible values, which are named constants.
• Examples of enumeration types include:
  • enum days {mon, tue, wed, thu, fri, sat, sun};
  • enum colors {red, blue, green, yellow, black};
• Evaluation of enumeration types:
  • Aid to readability, e.g., no need to code a color as a number
  • Aid to reliability, e.g., compiler can check operations and prevent assignment of values outside the defined range

Array Types

• An array is a homogeneous aggregate of data elements, where an individual element is identified by its position in the aggregate, relative to the first element.
• The individual data elements of an array are of the same type.
• References to individual array elements are specified using subscript expressions.
• Indexing (or subscripting) is a mapping from indices to elements.
• Index syntax varies between languages, with some using parentheses and others using brackets.

Record Types

• A record is a heterogeneous aggregate of data elements, where each element is a field.
• Fields are identified by their names.
• Access to record fields is much faster than access to array elements, because field names are static.

Pointer and Reference Types

• A pointer type variable has a range of values that consists of memory addresses and a special value, nil.
• Pointers provide the power of indirect addressing and 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).
• Pointer operations include:
  • Assignment: setting a pointer variable's value to some useful address
  • Dereferencing: yielding the value stored at the location represented by the pointer's value

Type Checking and Strong Typing

• Type checking is the activity of ensuring that the operands of an operator are of compatible types.
• Compatible type is one that either is legal for the operator or is allowed under language rules to be implicitly converted to a legal type.
• Coercion is the automatic conversion done by the compiler/interpreter.
• Type error is the application of an operator to an operand of an inappropriate type.
• Strongly typed programming languages are those that detect type errors.
• Examples of strongly typed languages include Java and C#, while C and C++ are not strongly typed languages.