chapter 11 and 12: abstract data types and encapsulation constructs; support for object orientation...

Chapter 11 and 12: Abstract Data Types and Encapsulation Constructs; Support for Object

Orientation

Lesson 11

Object Orientation Been using it for a while

CS101 and 102: Java This class: C++ and Ruby

04/19/23Chapts 11&12:ADTs, Encaps, and OO2

Abstract Data Types

Abstraction A view or representation

of an entity that includes only the most significant attributes

Simplification Ubiquitous in

programming: even a “float” is an abstraction


int i;float sum;sum = 0.0;for(i=0;i<10;i++){ sum += .1;}printf("%1.10f\n",sum);

int i;float sum;sum = 0.0;for(i=0;i<10;i++){ sum += .1;}printf("%1.10f\n",sum);

1.0000001192

Abstract Data Type

An Abstract Data Type is a user-defined data type that satisfies the following two conditions: Both representation and operations

are defined in a single syntactic unit The representation is hidden


Examples Most commonly ADTs defined in “class”

definitions E.g. C++, Java, C#, Ruby, SmallTalk, Eiffel

There are exceptions E.g. Ada: defined in nestable packages

04/19/235 Chapts 11&12:ADTs, Encaps, and OO

An interesting issue… C++ and Java Some design paradigms call for message

exchanges between objects, or it might just be nice for two classes to have knowledge of one another

In C++ one approach might be for each object to have a pointer to the other object


objA

objB

objB.hello()

objA.helloYourSelf()

Parameterized Abstract Data Types

Parameterized ADTs allow storage of any data type Example: a stack that can hold any type of data

Also known as generic classes In C++ known as templates Ruby is dynamically typed; therefore, its arrays,

vectors, queues, stacks, etc. are parameterized04/19/23Chapts 11&12:ADTs, Encaps, and OO7

Parameterized ADTs in C++ (continued) The stack element type can be parameterized

by making the class a templated class Should remember from project 6


template <class dataType> class Stack{ public: Stack(); ~Stack(); void push(dataType data); dataType pop(); void clear_stack(); void print_stack(); int size_of_stack() const; private: node<dataType> *pntrToHeadNode;};

Parameterized Classes in Java 5.0 (and C#)

Called Generics All collections are generics

Most common: LinkedList and ArrayList) They can hold any descendent of

“Object” class (i.e. pretty much any class)

3 issues prior to Java 5.0 Since interpreter didn’t know what data

type was coming off a generic data structure had to cast

Couldn’t force the collection to support only one type

Couldn’t store primitives Fixed first two: still can’t store

primitives04/19/23Chapts 11&12:ADTs, Encaps, and OO9

Encapsulation Constructs

Large programming projects: Need organization

Completely separate files containing related code Name spaces (so many commands and vars already

taken in libraries) Partial compilation

Separate files compiled independently

Such collections are called encapsulation04/19/2310 Chapts 11&12:ADTs, Encaps, and OO

Encapsulation in C Files containing one or more subprograms can

be independently compiled The interface is defined in a header file #include preprocessor specification – used to

include header files in applications


Should remember from Project 5: Modularizing your

code

Encapsulation in C++ Can define header and code files, similar to

those of C Or, classes can be used for encapsulation

The class is used as the interface (prototypes) The member definitions are defined in a separate

file Friends provide a way to grant access to

private members of a class Can define another class or another external

procedure as a friend


Classes definitely a form of encapsulation (which is why they are in the same lesson)

Language Examples: C++ (continued) Friend functions or classes - to provide access

to private members to some unrelated units or functions Necessary in C++ Might list a binary tree as a friend class to the node


class Node { private: int data; int key; // ... // class BinaryTree can now access data directly friend class BinaryTree;};

class Node { private: int data; int key; // ... // class BinaryTree can now access data directly friend class BinaryTree;};

Ada Packages

Ada packages can have multiple ADTs, and they can be given special access to one another (like friend classes)

Ada packages can be compiled separately A package’s specification and body parts

can be compiled separately


C# Assemblies

A collection of files Used in the “assemble” of a

dynamic link library (or even executable)


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


vector<Employee*>::iterator myIterator;std::cout << "print some text\n";

Java Packages

Packages can contain more than one class definition; classes in a package are partial friends Protected modifier allows fellow

package members access Clients of a package can use

fully qualified name or use the import declaration


Ruby modules Typically encapsulate collections of

constants and methods Access to the contents of a module is

requested with the require method (or load; require can handle binary modules)


require ‘myStuffMod’…MyStuff.mymethod1(x)

Module MyStuff PI = 3.114159265 def MyStuff.mymethod1(p1) … end

def MyStuff.mymethod2(p2) … endend


Support for Object OrientationChapter 12

OO Implementation Approaches1. Exclusive use of objects (everything is an

object)2. Full support for all existing imperative

language features and add OO to the language

3. Exclusive use of objects except for support for primitives


Messages

Calls to methods in objects are often called messages

Collection of methods called the message protocol or message interface


objA

objB

objB.hello()

objA.helloYourSelf()

Nested classes? Have we seen? Could have put node inside of the stack class

Instead of as a class defined in the H file


Stack

NodeNode

Software reuse: drives need of OOP A class is never quite perfect for the end user Can reuse what want and add other needed

parts through inheritance


Inheritance: Subclasses vs. Subtypes Stack might inherit from a LinkedList class If all public aspects of the linked list class are

accessible when using the stack class the stack class is a subtype

If want to hide some parent attributes or methods but make them available to children can declare as protected-derived


class BaseClass{ public: … protected: … private: …};

class BaseClass{ public: … protected: … private: …};

class DerivedClass : protected BaseClass{ //can access public and protected portions //of Base from this class but users of this //class cannot};

class DerivedClass : protected BaseClass{ //can access public and protected portions //of Base from this class but users of this //class cannot};

Multiple inheritance Some languages allow

C++ does SmallTalk, not so much

Adds complexity If both parents have the

same variable/method name, which inherit?

What if both bases were derived from a single parent and both overrode a method. Which to use?


Base Class

1

Base Class

2

Derived

Class

class D: public A, public B{ …};

class D: public A, public B{ …};

Allocation and deallocation and polymorphism Objects as local variables

Allocated on stack, right? How much room must be allocated if want to

support polymorphism? i.e. if a BaseClass object is passed in as an argument,

but the function must be able to deal with it or any of its DerivedClass objects

How fix? (remember project 7)


More polymorphism How do we tell the compiler that a user might

want to override a base class method (i.e. dynamic binding)?

Virtual keyword Why do you think we needed a virtual

destructor, also? If need dynamic binding there might be other

differences between base and derived Would want to run the derived’s destructor (i.e.

virtual)


Data storage

Support for polymorphism Class instance record (CIR: where allocated?)


class A{ int a,b; virtual void draw(); virtual void area();}

class A{ int a,b; virtual void draw(); virtual void area();}

class B : public A{ int c,d; void draw(); void area(); void sift();}

class B : public A{ int c,d; void draw(); void area(); void sift();}

Data storage (multiple inheritance) Order matters Which code executes: myC.fun(); ?


class A{ int a; virtual void fun(); virtual void init();}

class A{ int a; virtual void fun(); virtual void init();}

class B { int b; virtual void sum();}

class B { int b; virtual void sum();}

class C : public A, public B { int c; void fun(); void dud();}

class C : public A, public B { int c; void fun(); void dud();}

Where is everything? Could this work?


#include <iostream>using namespace std;

class Base{ public: static void initialize(){ cout << "look ma, no object\n"; }};

int main(int argc, char * argv[]){ Base *myBase; myBase = NULL; myBase->initialize(); return(0);}

#include <iostream>using namespace std;

class Base{ public: static void initialize(){ cout << "look ma, no object\n"; }};

int main(int argc, char * argv[]){ Base *myBase; myBase = NULL; myBase->initialize(); return(0);}

Let’s see if we can guesse Note the static

and the virtual


class Base{ public: static void initialize(){ cout << "look ma, no object\n"; } virtual void virt(){ cout << "hi I am virtual\n"; }};

class DerivedClass : public Base{ public: void howdy(){ cout << "howdy\n"; } void virt(){ cout << "hi, I'm D's virtual\n"; }};

What do you think the output will be?


int main(int argc, char * argv[]){ Base *myBase; myBase = NULL; myBase->initialize(); DerivedClass myD; printf("address of base initialize: %p\n",(void*)myBase->initialize); printf("address of derived initialize: %p\n",(void*)myD.initialize); printf("address of derived howdy: %p\n",(void*) &DerivedClass::howdy); printf("address of base virt: %p\n",(void*) &Base::virt); printf("address of derived virt: %p\n",(void*) &DerivedClass::virt); return(0);}

int main(int argc, char * argv[]){ Base *myBase; myBase = NULL; myBase->initialize(); DerivedClass myD; printf("address of base initialize: %p\n",(void*)myBase->initialize); printf("address of derived initialize: %p\n",(void*)myD.initialize); printf("address of derived howdy: %p\n",(void*) &DerivedClass::howdy); printf("address of base virt: %p\n",(void*) &Base::virt); printf("address of derived virt: %p\n",(void*) &DerivedClass::virt); return(0);}

Will base virt be at a different address than derived?How about base and derived initialize?

How a null object can access a method

Every class has a “sliver” of data stored in the “data” section of a program

It contains static variables including pointers to static methods

And it contains offsets to data and pointers to non-virtual methods (used when instantiating CIR’s)


Class Static Data

Class Static

Methods

The end


chapter 11 and 12: abstract data types and encapsulation constructs; support for object orientation...

Documents

printfaddress of base

mybase mybase

virt return0

null mybase

different address

sliver of data

data section

null object