records n.
Skip this Video
Loading SlideShow in 5 Seconds..
Records PowerPoint Presentation
Download Presentation

Loading in 2 Seconds...

play fullscreen
1 / 23

Records - PowerPoint PPT Presentation

  • Uploaded on

Records. Record aggregate of data elements Possibly heterogeneous Elements/slots are identified by names Elements in same fixed order in all records Design Issues : 1. What is the form of references ? 2. What unit operations are defined?. Record References. Definition Syntax COBOL

I am the owner, or an agent authorized to act on behalf of the owner, of the copyrighted work described.
Download Presentation

PowerPoint Slideshow about 'Records' - coy

An Image/Link below is provided (as is) to download presentation

Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author.While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server.

- - - - - - - - - - - - - - - - - - - - - - - - - - E N D - - - - - - - - - - - - - - - - - - - - - - - - - -
Presentation Transcript
  • Record aggregate of data elements
    • Possibly heterogeneous
    • Elements/slots are identified by names
    • Elements in same fixed order in all records
  • Design Issues:

1. What is the form of references?

2. What unit operationsare defined?

record references
Record References
  • Definition Syntax
    • COBOL
      • level numbers for nested records
    • Other PLs
      • recursive definition
  • Field References
    • COBOL
      • field_nameOF record_name_1 OF ... OFrecord_name_n
    • Other PLs use dot notation
      • record_name_1.record_name_2. ... .record_name_n.field_name
    • Fully qualified references include all record names
    • Elliptical references allow leaving out record names if the reference is unambiguous
    • Pascal's with clause allows to abbreviate references
record compile time descriptor
Record Compile-Time Descriptor

field 1

field n

A compile-time descriptor for a record

operations on records
Operations on Records
  • Assignment
    • Pascal, Ada, C
      • allowed it if the types are identical
    • Ada
      • RHS can be an aggregate constant
  • Initialization
    • Allowed in Ada
      • Allowed using an aggregate constant
  • Comparison
    • Ada
      • = and /=; one operand can be an aggregate constant
  • Move Corresponding
    • COBOL
      • Moves all fields in the source record to fields with the same names in the destination record
      • Note: the fields may not be in the same order
arrays vs records
Arrays vs. Records
  • Access to array elements is slower than access to record fields
    • Array subscripts are dynamic
    • Field names are static
  • Dynamic subscripts for record fields?
    • but type checking would be complex
    • it would be much slower
  • Union
    • Elements can store different type values during execution
  • Discriminatedunion
    • tags for indicating types for type checking
  • Free union
    • notype checking
  • Design Issues for unions
    • What kind of type checking should be done?
    • Should unions be integrated with records?
    • EQUIVALENCE, No type checking
  • Pascal
    • both discriminated and nondiscriminated unions

Different fields

Common fields

A discriminated union of three shape variables

discriminant field form determines which fields have data values

type checking of unions
Type Checking of Unions
  • Pascal’s can’t be type checked effectively:
    • User can create inconsistent unionsbecause the tag can be individually assigned

var blurb : record case tag: boolean;

true: (i: integer;)

false: (x: real;)


blurb.tag := true; {it's i, an integer}

blurb.i := 47; {ok }

blurb.tag := false; {it's now x, a real!}

write (blurb.x); {writes 47 as real?!}

    • The tag is optional!
union examples cont
Union Examples, cont.
  • Ada
    • discriminated unions
      • No inconsistent unions, safer than Pascal
        • Tag must be present
        • Tag cannot be assigned by itself
        • All assignments to the union must be aggregate values that include the tag
  • C and C++
    • free unions (no tags)
      • Not part of their records
      • No type checking of reference
  • Java has neither records nor unions
  • Evaluation
    • potentially unsafe in most languages (not Ada)
  • Unorderedcollection of distinctvalues from some ordinal type
  • Operations
    • Union
    • Intersection
    • Difference
  • Design Issue
    • Maximum number of elements in the set base type
pointers and references
Pointers and References
  • Provide access to dynamic storage
  • Pointers
    • The address of the data – a number
    • Flexible – you can do arithmetic on the addresses!
    • Few, if any safety checks on access using pointers
    • E.g. C, C++
  • References
    • Points to the data implicitly
    • No address arithmetic
    • Much safer
    • E.g. Java, Lisp
heap storage
Heap Storage

Implicit –


Explicit –








problems with pointers
Problems with Pointers
  • Dangling pointers (dangerous)
    • A pointer to a heap-dynamic variable that has been de-allocated
    • To create a dangling pointer
      • Allocate a heap-dynamic variable with one pointer
      • Set a second pointer to the value of the first pointer
      • De-allocate the variable using the first pointer
      • Second pointer is now dangling
  • Lost Variables / MemoryLeaks(wasteful)
    • A heap-dynamic variable that is no longer referenced
    • To create a lost variable:
      • Allocate a heap-dynamic variable with a pointer
      • Set the pointer to another heap-dynamic variable
pascal and ada pointers
Pascal and Ada Pointers
  • Pascal: only for dynamic storage management
    • Explicit dereferencing necessary - postfix ^
    • Dangling pointers are possible - explicit dispose
    • Memory leaks are possible
  • Ada
    • A little better than Pascal
    • Some dangling pointers are avoided
      • Dynamic data is automatically de-allocated at the end of pointer's type scope
    • All pointers are initialized to null
    • Memory leaks possible
      • Rare, as explicit deallocation is rarely done
c and c pointers
C and C++ Pointers
  • C and C++
    • Explicit dereferencing and address-of operator
    • Domain type need not be fixed - void *
    • void * can point to any type and can be type checked (cannot be de-referenced)
    • Address arithmetic in restricted forms, e.g.:

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]

pointer assignment
Pointer Assignment

The assignment operation j = *ptr

fortran pointers
FORTRAN Pointers
  • FORTRAN 90
    • Can point to heap and non-heap variables
    • Implicitdereferencing
    • Pointers only to variables with TARGETattribute
    • TARGETattribute in declaration


    • A special assignment operator for non-dereferenced references

REAL, POINTER :: ptr (POINTER is an attribute)

ptr => target

where target is pointer or non-pointer with TARGET attribute

      • This sets ptrto have the same value as target
c and java pointer references
C++ and Java Pointer/References
  • C++
    • Reference Types
      • Constant pointers that are implicitly dereferenced
      • Used for parameters
        • Advantages of both pass-by-reference and pass-by-value
  • Java
    • Only references, no pointers
    • No pointer arithmetic
    • Can point only to objects (all on the heap)
    • No explicit deallocator
      • Garbage collection is used
      • No dangling references
    • Dereferencing is always implicit
      • No memory leaks
dangling pointers
Dangling Pointers

Solutions to dangling pointer problem

  • Tombstone
    • Extra heap cell that is points to the heap-dynamic variable
    • The actual pointer variable points only at tombstones
    • Deallocating heap-dynamic variable sets tombstone to nil
    • Another pointer can't use it anymore
  • Locks and keys
    • Pointer is represented as (key, address) pair
    • Heap-dynamic variable has extra lock cell
    • Allocating heap-dynamic variable places lock value in lock cell
    • Pointers have a copy of the lock value in the key cell
    • Deallocating the variable sets its lock cell to an illegal value
    • Access via other pointers then causes an error
heap management
Heap Management
  • Single-size cells vs. variable-size cells
  • Reference counters vs. garbage collection (lazy approach)
  • Reference counter
    • Every heap-dynamic variable has a counter of pointers currently pointing to it
    • Once counter becomes 0 memory can be reclaimed
    • Eagerapproach
    • Disadvantages
      • Space required
      • Execution time required
      • Complications for cells connected circularly
garbage collection
Garbage Collection
  • Garbage collection
    • Allocate and disconnect
    • When all available cells are allocated, gather all garbage
    • Every heap cell has an extra garbage collection bit
      • All cells initially set to garbage
      • All reachable cells marked as not garbage
      • All garbage cells returned to list of available cells
    • Disadvantage
      • When you need it most, it works worst
      • Takes most time just when program needs cells in heap most
    • More efficient methods don’t wait until absolutely necessary
evaluation of pointers
Evaluation of Pointers
  • Pointers or references are necessary for dynamic data structures
    • No modern PL can't be without them
  • Pointers are like goto's
    • They widen the range of memory cells that a variable can access
  • Dangling pointers are a problem
  • Memory leaks are a problems
  • Heap management is a problem