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();
}
}
