Transcript Slide 1

Abstract data types &
object-oriented paradigm
Abstraction
• Abstraction: a view of an entity that includes
only the attributes of significance in a
particular context.
• Two fundamental abstractions: process
abstraction & data abstraction
• Process abstraction: sortInt(list, list_len)
– sorting algorithms is not revealed
– user code remains same even implementation of
sorting algorithm is changed
– used for a long time
Abstract data type
• Abstract Data Type: an encapsulation that
includes only the data representation and
the subprograms that provides operations
for that type.
– reliability: user cannot directly access objects
– readability: without implementation details
Introduction to Data
Abstraction
• Built-in types are abstract data types
e.g. int type in Java
– The representation is hidden
– Operations are all built-in
– User programs can define objects of int type
• User-defined abstract data types must have
the same characteristics as built-in abstract
data types
– To declare variables of that type
– A set of ops
Abstract data type example
interfaces:
create(stack)
destroy(stack)
empty(stack)
push(stack, item)
pop(stack)
top(stack)
code example:
…
create(stk1);
push(stk1, 34);
push(stk1, 20);
if ( !empty(stk1) )
temp = top(stk1);
• stack implementation can be changed
from array to list w/o affecting the code
Encapsulation
• Encapsulation: a grouping of
subprograms and the data they
manipulate
• Hiding the implementation details of the
abstract interface
• Protect internal data
• Reliability, maintenance
Language Examples-C++
• Based on C struct type and Simula 67
classes
• The class is the encapsulation device
• All of the class instances of a class share a
single copy of the member functions
• Each instance of a class has its own copy of
the class data members
• Instances can be static, stack dynamic, or
heap dynamic
At first glance
#include <iostream.h>
void push(int item) {
class stack {
if (topPtr == maxLen)
private:
cerr << “Stack full\n”;
int *stackPtr;
else stackPtr[++topPtr] = item;
int maxLen; Data members
}
int topPtr;
void pop() {
public:
if (topPtr == -1)
stack() {
cerr << “Stack empty\n”;
stackPtr = new int [100];
else topPtr--;
maxLen = 99;
}
Member functions
topPtr = -1;
int top() {
}
return ( stackPtr[topPtr] ); }
~stack() {
int empty() {
delete [ ] stackPtr;
return ( topPtr == -1); }
}
} // end class stack
C++ Class
• data members: data defined in a class
– *stack_ptr, max_len, top_ptr
• member functions: functions defined in a
class
– also called access interfaces
– push( ), pop( ), top( ), empty( )
• private: entities (data or member functions)
that are to be hidden from outside the class
• public: entities (data or member functions)
that are visible outside the class
C++ class (con’t)
• constructor: initialize the data members
of newly created objects
– stack( )
– implicitly called when an object of the class
type is created
– can have one or more constructor for a
class
• destructor: implicitly called when the
lifetime of an instance of the class ends
– ~stack( )
Example in C++
#include <iostream.h>
class stack {
private:
int *stackPtr;
int maxLen;
int topPtr;
public:
stack() {
stackPtr = new int [100];
maxLen = 99;
topPtr = -1;
}
~stack() {
delete [ ] stackPtr;
}
void push(int item) {
if (topPtr == maxLen)
cerr << “Stack full\n”;
else stackPtr[++topPtr] = item;
}
void pop() {
if (topPtr == -1)
cerr << “Stack empty\n”;
else topPtr--;
}
int top() {
return ( stackPtr[topPtr] ); }
int empty() {
return ( topPtr == -1); }
} // end class stack
Class usage in C++
Code example in C++:
void main() {
int topOne;
stack stk;
// stack-dynamic
stk.push(42);
stk.push(20);
topOne = stk.top();
stk.pop();
…
// stk being freed
}
• stack stk 
constructor is
called to initialize
the instance
• at the end of the
main, stk’s
destructor is
called
Language Examples
• Constructors:
– Functions to initialize the data members of
instances
– May also allocate storage if part of the object is
heap-dynamic
– Can include parameters to provide
parameterization of the objects
– Implicitly called when an instance is created
– Can be explicitly called
– Name is the same as the class name
Language Examples
• Destructors
– Functions to cleanup after an instance is
destroyed; usually just to reclaim heap
storage
– Implicitly called when the object’s lifetime
ends
– Can be explicitly called
– Name is the class name, preceded by a
tilde (~)
Examples in Java
• Java uses implicit garbage collection (no destructor)
and reference variable (not pointer)
Code example in Java:
Code example in C++:
public class TestStack {
void main() {
public static void main(…) {
int topOne;
INTEGER topOne;
stack stk; // stack-dynamic
StackClass myStack =
stk.push(42);
new StackClass();
stk.push(20);
myStack.push(42);
topOne = stk.top();
myStack.push(20);
stk.pop();
topOne = myStack.top();
…
myStack.pop();
}
…
}
Java features
• Stack_class does not have destructor
– implicit garbage collector
• In main( ), myStack does not get freed
– implicit garbage collector
• The use of reference variables
– Java does not support pointer
Example:Stack in Java
import java.io.*;
class Stack_class {
private int [ ] stack_ref;
private int max_len,
top_index;
public Stack_class( ) {
stack_ref = new int [100];
max_len = 99;
top_index = -1;
}
public void push (int number) {
if (top_index = max_len)
System.out.println(
“Error stack full”);
else
stack_ref[++top_index] =
number;
}
public void pop( ) {
if (top_index == -1)
System.out.println(
“Error Stack empty”);
else –top_index;
}
public int top( ) {
return (stack_ref[top_index]); }
public boolean empty( ) {
return (top_index == -1); }
} // end class stack
Parameterized Abstract Data
Types- C++
• Templated Classes
– Classes can be somewhat generic by
writing parameterized constructor functions,
e.g.
stack (int size)
{
stk_ptr = new int [size];
max_len = size - 1;
top = -1;
}
stack stk(100);
Parameterized Abstract Data
Types
• The stack element type can be
parameterized by making the class a
templated class
• Java does not support generic abstract
data types
Parameterized Abstract Data in
C++
#include <iostream.h>
void push(int item) {
if (topPtr == maxLen)
class stack {
cerr << “Stack full\n”;
private:
else stackPtr[++topPtr] = item;
int *stackPtr;
}
int maxLen;
void pop() {
int topPtr;
if (topPtr == -1)
public:
cerr << “Stack empty\n”;
stack(int size) {
else topPtr--;
stackPtr = new int [size];
}
maxLen = size -1;
int top() { return ( stack[topPtr] ); }
int empty() {
topPtr = -1;
return ( topPtr == -1); }
}
} // end class stack
~stack() {
delete [ ] stackPtr;
Usage: stack myStack(50);
}
Template abstract data type in
C++
#include <iostream.h>
template <class Type>
class stack {
private:
Type *stackPtr;
public:
stack()
: stackPtr (new Type [100]),
maxLen (99), topPtr(-1)
{}
stack(int size) {
stackPtr = new Type [size];
maxLen = size – 1;
topPtr= -1; }
• C++ example in left
stack<int> stk;
stack<int> stk(150);
• C++ template classes
are instantiated at
compile time
– code for new type is
created when not
existed
• Java does not support
generic abstract data
type as in left
Encapsulation Constructs
• Original motivation:
– Large programs have two special needs:
1. Some means of organization, other than simply
division into subprograms
2. Some means of partial compilation (compilation
units that are smaller than the whole program)
• Obvious solution: a grouping of subprograms
that are logically related into a unit that can
be separately compiled (compilation units)
– These are called encapsulations
Encapsulation Constructs
•
•
Nested subprograms in Ada and Fortran 95
Encapsulation in C
– Files containing one or more subprograms can
be independently compiled
– The interface is placed in a header file
– Problem: the linker does not check types
between a header and associated
implementation
•
Encapsulation in C++
– Similar to C
– Addition of friend functions that have access to
private members of the friend class
Naming Encapsulations
• Large programs define many global
names; need a way to divide into logical
groupings
• A naming encapsulation is used to
create a new scope for names
• C++ Namespaces
– Can place each library in its own
namespace and qualify names used
outside with the namespace
– C# also includes namespaces
OO Key feature
• Abstraction
– Well-defined interface
• Hierarchy
– Composition
– Derivation
– inheritance
• Encapsulation
– Hiding the detail
• Polymorphism
From C to C++
• Without abstraction
main(){
int stack_items[STACKSIZE], stack_top =0, x;
/*push x into stack*/
stack_item[stack_top++] = x;
/*pop stack to x*/
x = stack_item[--stack_top];
}
Abstraction
• Abstraction:
void init(stack *s;
viod push(stack *s, int i);
int pop(stack *s);
void cleanup(stack *s);
typedef struct{
int items[stacksize];
Int top
} stack;
Void init(stack *s) {s->top = 0;}
Void push (stack *s, int i) {s->
items[s->top++] =I;}
Int pop(stack *s){return s->items[-s->top];}
…
main(){
int x;
stack stack1;
init(&stack1);
push(&stack1, x);
…
}