Scribd
Upload
27 views

Chapter 5: Elementary Data Types

This document summarizes elementary data types and concepts including: 1) Data objects can contain data values and be manipulated as units, while data structures combine multiple data objects. 2) Data types determine allowed values and operations for data objects and are specified through attributes, values, and operations. 3) Variables and constants represent data objects in programs, with variables defined by programmers and constants permanently bound to a value. 4) Declarations provide type information for data objects used in programs to guide storage representation, management, and type checking.

Uploaded by

Gaurav
Copyright
© Attribution Non-Commercial (BY-NC)
Available Formats
Download as PPT, PDF, TXT or read online on Scribd
27 views

Chapter 5: Elementary Data Types

This document summarizes elementary data types and concepts including: 1) Data objects can contain data values and be manipulated as units, while data structures combine multiple data objects. 2) Data types determine allowed values and operations for data objects and are specified through attributes, values, and operations. 3) Variables and constants represent data objects in programs, with variables defined by programmers and constants permanently bound to a value. 4) Declarations provide type information for data objects used in programs to guide storage representation, management, and type checking.

Uploaded by

Gaurav
Copyright
© Attribution Non-Commercial (BY-NC)
Available Formats
Download as PPT, PDF, TXT or read online on Scribd
You are on page 1/ 31

Chapter 5: Elementary Data Types

• Properties of types and objects


– Data objects, variables and constants
– Data types
– Declarations
– Type checking
– Assignment and initialization
Data Objects
• a run-time grouping of one or more
pieces of data in a virtual computer.
• a location in memory with an
assigned name in the actual computer.
 

Programmer defined data objects


System defined data objects
Concepts
Data value: a bit pattern that is
recognized by the computer.
Elementary data object: contains a data value
that is manipulated as a unit.
Data structure: a combination of data objects.

Attributes: determine how the location


may be used.
Most important attribute - the data type.
Attributes and Bindings
Type: determines the set of data
values that the object may take and the
applicable operations.
  Name: the binding of a name to a
data object.
  Component: the binding of a data
object to one or more data objects.
These attributes are bound at translation
Attributes and Bindings

Location: the storage location


in memory assigned by the system
(bound at loading)

  Value: the assignment of a bit


pattern to a name (bound at
execution)
Variables and Constants

In programs, data objects are


represented as variables and constants

Variables : Data objects defined and


named by the programmer explicitly.
Variables and Constants
Constants:
Data objects with a name that is
permanently bound to a value for its
lifetime.
Literals: constants whose name is the
written representation of their value.
A programmer-defined constant: the
name is chosen by the programmer in a definition of
data object.
Persistence: existence of data beyond run time
Data Types
A data type is a class of data
objects with a set of operations
for creating and manipulating
them.

Examples of elementary data types:


integer, real, character, Boolean, enumeration,
pointer.
Specification of a data type

•Attributes
•Values
•Operations
Attributes
Distinguish data objects of a given type
Data type and name - invariant during the lifetime
of the object

Approaches:
• stored in a descriptor and used during the
program execution
• used only to determine the storage
representation, not used explicitly during
execution
Values
The data type determines the values that
a data object of that type may have

Specification: Usually an ordered set,


i.e. it has a least and a greatest value
Operations
Operations define the possible manipulations
of data objects of that type.
• Primitive - specified as part of the
language definition
• Programmer-defined (as subprograms,
or class methods)
Operations
An operation is defined by:
·         Domain - set of possible input
arguments
·         Range - set of possible results
·         Action - how the result is produced
Operation signature
Specifies the domain and the range
• the number, order and data types of the
arguments in the domain,
• the number, order and data type of the
resulting range
mathematical notation for the specification:
op name: arg type x arg type x … x arg type
 result type
The action is specified in the operation implementation
Sources of ambiguity in
operations
• Undefined operations for certain inputs.

• Implicit arguments, e.g. use of global


variables
• Implicit results - the operation may modify its
arguments
• Self-modification - usually through change of
local data between calls, e.g. random number
generators change the seed.
Implementation of a data type

• Storage representation
• Implementation of operations
Storage representation

Influenced by the hardware


Described in terms of:
Size of the memory blocks
required
Layout of attributes and data
values within the block
Methods to treat attributes
 

a       determined by the compiler and not


stored in descriptors during execution - C

b    stored in a descriptor as part of the


data object at run time - LISP Prolog
Implementation of
operations

• Hardware operation: direct implementation.


E.g. integer addition
• Subprogram/function, e.g. square root
operation
• In-line code. Instead of using a subprogram, the
code is copied into the program at the point
where the subprogram would have been invoked.
Declarations
Information about the name and
type of data objects needed
during program execution.
 
Explicit – programmer defined
Implicit – system defined
Examples

FORTRAN - the first letter in the name of the


variable determines the type

Perl - the variable is declared by assigning a value


$abc = 'a string' $abc is a string variable
$abc = 7 $abc is an integer variable
Declarations of operations

prototypes of the functions or


subroutines that are programmer-
defined.
Examples:
declaration: float Sub(int, float)
signature: Sub: int x float --> float
Purpose of declaration

• Choice of storage representation


• Storage management
• Polymorphic operations
• Static type checking
Type Checking versus Type
Conversion

Type checking: checking that each


operation executed by a program
receives the proper number of
arguments of the proper data types.
 
Static type checking is done at compilation.
Dynamic type checking is done at run-time.
• Strong typing: all type errors can be
statically checked
• Type inference: implicit data types, used
if the interpretation is unambiguous.
• Type Conversion and Coercion
  Coercion: Implicit type conversion,
performed by the system.
  Explicit conversion : routines to
change from one data type to another.
Explicit conversion
Pascal: the function round -
converts a real type into integer

C - cast, e.g. (int)X for float X


converts the value of X to type
integer
Coercion
Two opposite approaches
• No coercions, any type mismatch
is considered an error : Pascal, Ada

• Coercions are the rule. Only if no


conversion is possible, error is
reported.
Coercion:
advantages and disadvantages

Advantages: free the programmer


from some low level concerns,
as adding real numbers and integers.

Disadvantages: may hide serious


programming errors.
Assignments
Assignment - the basic operation for
changing the binding of a value to a data
object.
The assignment operation can be defined
using the concepts L-value and R-value
L-value: Location for an object.
R-value: Contents of that location.
Value, by itself, generally means R-value
Example
A=A+B;

• Pick up contents of location A:


R-value of A
• Add contents of location B:
R-value of B
• Store result into address A:
L-value of A
Initialization
Uninitialized data object - a data
object has been created, but no value
is assigned,
i.e. only allocation of a block storage
has been performed.
 
Implicit and explicit initialization

You might also like