IA010: Principles of Programming Languages · This notion is used (in the context of programming...

IA010: Principles of ProgrammingLanguages

7. Abstract Data Types

Jan Obdržálek [email protected]

Faculty of Informatics, Masaryk University, Brno

IA010 7. Abstract Data Types 1

mailto:[email protected]

Abstraction

A view or representation of an entity which retains only themost significant attributes.


Abstraction

A view or representation of an entity which retains only themost significant attributes.

• bird vs. carrion crow vs. chiffchaff• which attributed have birds in common?• common attributes of birds can be abstracted away

(in the descriptions of crow/chiffchaff)• different levels of abstraction

(c.Aves, o.Passeriformes, f.Corvidae, g.Corvus)• why use abstraction in programming?

• increases readability• hides (at the given time) unimportant details⇒ decreases complexity

• two main kinds:• process abstraction (subroutines)• data abstraction (ADTs)


Outline

Introduction to ADTs

ADTs in Ada

ADTs in C++

Parameterized ADTs

Encapsulation topics


Introduction to ADTs


Abstract data types (ADTs)Definition

An abstract data type (ADT) is a mathematical model of a datastructure which is defined by its operations.

vs

ADT is a data type with the following properties:• The representation of objects of the type is hidden from

program units using the type. hiding• Declarations of the type and the protocols of the operations

on objects of the type (type’s interface) are contained in asingle syntactic unit. The interface is independent of theimplementation, and all other units (the clients) can createvariables of this type. encapsulation


ADT example: a stack

operations (the interface)

• create(stack)

• destroy(stack)

• empty(stack)

• push(stack, element)

• pop(stack)

• top(stack)


Origins of data abstraction

Built-in types as ADTs?• All built-in types are, in a way, abstract data types.• Example: float

• the inner representation (significand + exponent) is hiddenfrom the user

• the only operations available are those provided by thelanguage (the user cannot create new operations)

• portability: the program will work for any innerrepresentation (IEEE 754 is from 1985)

First ADTs• records in COBOL (data structure—in the form of a

record—plus subroutines manipulating it)

Object-oriented programming (OOP)• ADT != OOP (Even though our examples will be OO.)• OOP is the logical next step beyond data abstraction• data abstraction is one of the main ingredients of OOP


Encapsulation

This notion is used (in the context of programming languages)in two meanings (or their combinations):

1 a mechanism for restricting access to some fields of anobject⇒ information hiding

2 a language construction for associating data withoperations over these data


Benefits of information hiding

• increases reliability• clients cannot directly manipulate the inner representation⇒ helps to guarantee the integrity of objects

• reduces the amount of code the programmer must beaware of

• the code is easier to understand• makes errors easier to find

• decreases the potential for name conflicts• the inner representation can be changed without affecting

the rest of the program(as long as the interface is preserved)

Note: It is necessary to have a mechanism which makes visiblefrom the outside only some of parts (typically operationdeclarations) of a unit.IA010 7. Abstract Data Types 10

Access to object’s data

• sometimes “direct” access to data members is needed• possible solutions

• make data visible to the outside• using accessor methods (setters/getters)

• advantages of using accessor methods• read-only access can be provided (just a getter)• constraints can be enforced in setters• possible to change inner implementation any time

Both solutions violate the ADT principles!


Further topics

Generic operations(in addition to the operation defining the ADT)

• all types• assignment (usually built into the language)• test for (in)equality

• some types• constructors and destructors• iterators• accessors

ADT design issues• type and interface representation• can ADTs be parameterized?• access control mechanism?• is the specification of a type separate from its

implementation?IA010 7. Abstract Data Types 12

ADTs in Ada


ADTs in Ada

• the first commercial language to offer a full support forADTs (together with Modula-2)

• ADTs are implemented using the encapsulation construct(provided by packages)

packages• two parts, sharing the same name

1 package specification (the interface)2 package body (the implementation)

• not all packages have the body part(if encapsulating only types and constants)

• both parts can be compiled separately(provided the specification is compiled first)

• for compiling client code, only the specification is needed


Information hiding in Ada

• by separating the specification into two parts:• the private part

• starts by the private keyword• always at the end• visible to the compiler, but not to client units

• the public part

• type representation must be given in the packagespecification(so the compiler can compute the size of type’s objects)

• two variants of private types:• private types

• assignment and (in)equality built-in• limited private types

• declared as limited private in the public part• no built-in operations (e.g. for stacks)


Ada stack specification

package Stack_Pack is-- The visible entities, or public interfacetype Stack_Type is limited private;Max_Size : constant := 100;function Empty(Stk : in Stack_Type) return Boolean;procedure Push(Stk : in out Stack_Type;Element : in Integer);procedure Pop(Stk : in out Stack_Type);function Top(Stk : in Stack_Type) return Integer;

-- The part that is hidden from clientsprivatetype List_Type is array (1..Max_Size) of Integer;type Stack_Type isrecordList : List_Type;Topsub : Integer range 0..Max_Size := 0;end record;

end Stack_Pack;


Ada stack implementation

with Ada.Text_IO; use Ada.Text_IO;package body Stack_Pack is

function Empty(Stk: in Stack_Type) return Boolean isbeginreturn Stk.Topsub = 0;end Empty;

procedure Push(Stk : in out Stack_Type; Element : in Integer) isbeginif Stk.Topsub >= Max_Size thenPut_Line("ERROR - Stack overflow");

elseStk.Topsub := Stk.Topsub + 1;Stk.List(Topsub) := Element;

end if;end Push;

...


ADTs in C++


ADTs in C++

• C++ was created by adding features to C• the first (and the most important one) was OOP• basic construct providing ADT functionality is the class• ADTs are also provided by the struct• classes are types• terminology:

• data: data members• operations: member functions• class members vs instance members

• access to class members only through some object (aninstance) of this class

• all instances share member functions, but not data


Information hiding in C++

• Method definitions and declarations• definitions in the definition file of the class (.cpp)• declarations in the header file (.h)• if both declaration and definition of a method are in the

header file, then the method is implicitly inline

• Information hiding – two clauses• private – hidden entities• public – public entities (the interface)• (protected – third possibility, OOP related)


Constructors and destructors

• Constructor• initializes data members of newly created objects• can allocate space on the heap• called implicitly when a new object of the class is created• same name as the class• does not return a value• can be overloaded

• Destructor• implicitly called at the end of object’s lifetime• typically used for deallocating space on heap• name: ‘~’ + class name• useful for debugging (printing debug info)• does not return a value


C++ stack specification

// Stack.h - the header file for the Stack class#include <iostream.h>class Stack {private: //** These members are visible only to other

//** members and friendsint *stackPtr;int maxLen;int topSub;

public: //** These members are visible to clientsStack(); //** A constructor~Stack(); //** A destructorvoid push(int);void pop();int top();int empty();

}


C++ stack implementation

// Stack.cpp - the implementation file for the Stack class#include <iostream.h>#include "Stack.h"using std::cout;Stack::Stack() { //** A constructorstackPtr = new int [100];maxLen = 99;topSub = -1;

}

Stack::~Stack() {delete [] stackPtr;}; //** A destructor

int Stack::empty() {return (topSub == -1);}

void Stack::push(int number) {if (topSub == maxLen)cerr << "Error in push--stack is full\n";else stackPtr[++topSub] = number;

}...IA010 7. Abstract Data Types 23

ADTs in Java

• similar to C++• differences:

• all objects allocated on the heap• each ADT defined and declared in a single file• each method is declared public/private separately

(third possibility - package access )• no destructors


Java stack example

class StackClass {private int [] stackRef;private int maxLen, topIndex;

public StackClass() { // A constructorstackRef = new int [100];maxLen = 99;topIndex = -1;

}

public boolean empty() {return (topIndex == -1);}

public void push(int number) {if (topIndex == maxLen)System.out.println("Error in push - stack is full");

else stackRef[++topIndex] = number;}

...


Parameterized ADTs


Parameterized ADTs in Adamodified examplegenericMax_Size : Positive; -- generic stack sizetype Element_Type is private; -- generic element type

package Generic_Stack is-- The visible entities, or public interfacetype Stack_Type is limited private;function Empty(Stk : in Stack_Type) return Boolean;procedure Push(Stk : in out Stack_Type; Element : in Element_Type);procedure Pop(Stk : in out Stack_Type);function Top(Stk : in Stack_Type) return Element_Type;

-- The part that is hidden from clientsprivatetype List_Type is array (1..Max_Size) of Element_Type;

...

new instancepackage Integer_Stack is new Generic_Stack(100, Integer);


Parameterized ADTs in Java 5.0

• generic parameters must be classes(see generic methods in Java 5.0)

• a generic class definition:public class MyClass<T> { ... }

Collections (before Java 5.0)• store instances of the Object type• disadvantages

1 need to type cast element after reading from a collection2 no type checking for insertion3 primitive types cannot be stored

(e.g. int needs to be encapsulated in Integer)

Generic collections (Java ≥ 5.0)ArrayList <Integer> myArray = new ArrayList <Integer>();


Java stack using generic collections

import java.util.*;public class Stack<T> {private ArrayList<T> stackRef;private int maxLen;

public Stack() { // A constructorstackRef = new ArrayList<T> ();maxLen = 99;

}

public boolean empty() {return (stackRef.isEmpty());}

public void push(T newValue) {if (stackRef.size() == maxLen)System.out.println("Error in push - stack is full");

elsestackRef.add(newValue);

}...


Encapsulation topics


Encapsulation – multiple types

the problem with large programs• “flat” colection of subroutines and ADTs is difficult to

intellectually handle• time-demanding recompilation

solution• organize the program into logically related collections of

code and data, which can be compiled separately(typical example: libraries)

• variants1 nested subroutines (unsatisfactory)2 ADTs (just one type per file)3 general collections (e.g. Ada packages)

(basically separate compilation in C (make))


Encapsulation – names

the problem with names• larger programs are today developed by (independent)

teams of programmers• massive use of third-party code⇒ real possibility of name collisions

solution: naming encapsulations• new name scopes are defined• e.g. each library has its own naming encapsulation• multiples collections of code can be put into the same

namespace (even if they reside in different files)

• languages: C++, Java, Ada, Ruby, . . .


Example: namespace in C++

• all required declarations are put into a common namespaceblock

namespace myNameSpace { // declarations go hereint foo()...

}

Access (3 variants)

1 myNameSpace:foostate the package on access

2 using myNameSpace::foo;foo is now visible in the unit

3 using namespace myNameSpace;all names of myNameSpace are now visible in the unit


Example: Java packages

• packages can contain multiple types(in this case classes and interfaces)

• if no access policy is specified, then visible for all othertypes in the same package: package scope

• specifying the package for a compilation unit:

package myPackage;

• access to package elements:• import myPackage.foo;• import myPackage.*;


IA010: Principles of Programming Languages · This notion is used (in the context of programming...

Documents

Transcript of IA010: Principles of Programming Languages · This notion is used (in the context of programming...