Programming Languages

Abstract Data Types and

Design Issues

Outline
The

Concept of Abstraction
Introduction to Data Abstraction
Design Issues
Language Examples

Abstraction
Two

types of abstractions:

Process abstraction: subprograms

Data abstraction

Floating-point

data type as data abstraction

The programming language will provide (1) a

way of creating variables of the floating-point

data type, and (2) a set of operators for
manipulating variables
Abstract away and hide the information of how
the floating-point number is presented and
stored

Abstraction Data Type

Abstract

data type: a user-defined data type

Declaration of the type and protocol of

operations on objects of the type, i.e., types

interface, are defined in a syntactic unit;
interface indep. of implementation
Representation of objects of the type is hidden
from program units that use these objects; only
possible operations are those provided in type's
definition
class data type int
object variable
i, j, k
method y = stack1.top()+3;
operators +, -, vs
*, / y = (-x) + 3;

Advantages of Data Abstraction

Advantage

of having interface
independent of object representation or
implementation of operations:
Program organization, modifiability

Advantage

of 2nd condition (info. hiding)

Reliability: By hiding data representations, user

code cannot directly access objects of the type

or depend on the representation, allowing the
representation to be changed without affecting
user code

cont.....

Design Issues and Language Examples

Language Requirements for ADTs

A

syntactic unit to encapsulate type definition

A method of making type names and
subprogram headers visible to clients, while
hiding actual definitions
Some primitive operations that are built into
the language processor
Example: an abstract data type for stack
create(stack), destroy(stack), empty(stack),

push(stack, element), pop(stack), top(stack)

Stack may be implemented with array, linked
list, ...

Abstract Data Types in C++

The

class is the encapsulation device

All of the class instances of a class share a single

copy of the member functions

Each instance has own copy of class data members
Instances can be static, stack dynamic, heap
dynamic
Information

hiding

Private clause for hidden entities

Public clause for interface entities
Protected clause for inheritance

Member Functions Defined in Class

class Stack {
private:
int *stackPtr, maxLen, topPtr;
public:
Stack() { // a constructor
stackPtr = new int [100];
maxLen = 99;
topPtr = -1;
~Stack () {delete [] stackPtr;};
void push (int num) {};
void pop () {};
int top () {};
int empty () {};
}

};

Language Examples: C++ (cont.)

Constructors:
Functions to initialize the data members of

instances (they do not create the objects)

May also allocate storage if part of the object
is heap-dynamic
Implicitly called when an instance is created
Can be explicitly called
Name is the same as the class name

Language Examples: C++ (cont.)

Destructors
Functions to clean up after an instance is

destroyed; usually just to reclaim heap storage

Implicitly called when the objects lifetime
ends
Can be explicitly called
Name is the class name, preceded by a tilde
(~)

Uses of the Stack Class

void main()
{
int topOne;
Stack stk; //create an
the Stack
stk.push(42); // c.f.,
stk.push(17);
topOne = stk.top(); //
stk.pop();
...
}

instance of
class
stk += 42
c.f., &stk

Abstract Data Types in Java

Similar

to C++, except:

All user-defined types are classes

All objects are allocated from the heap and
accessed through reference variables
Methods must be defined completely in a class
Individual entities in classes have access

control modifiers (private or public), rather

than clauses
No destructor implicit garbage collection

An Example in Java
class StackClass {
private int [] stackRef;
private int maxLen, topIndex;
public StackClass() { // a constructor
stackRef = new int [100];
maxLen = 99; topPtr = -1;};
public void push (int num) {};
public void pop () {};
public int top () {};
public boolean empty () {};
}

An Example in Java
public class TstStack {
public static void main(String[] args) {
StackClass myStack = new StackClass();
myStack.push(42);
myStack.push(29);
System.out.println(:+myStack.top());
myStack.pop();
myStack.empty();
}
}