class examples (simple, airplane, queue, pile) copy vs. clone

Class Examples(Simple, Airplane, Queue, Pile)

Copy vs. Clone

Class Examples

Simple, Airplane, Queue, Pile

World’s Simplest Class!class Simple

public

Procedure setValue(dataIn isoftype in Number)

// Precon: Initialization

// Purpose: Sets value to dataIn

// Postcon: Value is changed

Function getValue returnsa Num()

// Precon: Initialization

// Purpose: Returns value to user

// Postcon: No changes to object

Procedure Initialize()

// Precon: Object exists

// Purpose: Initialization

// Postcon: Value is defined to be zero

LB

(continued) protected

value isoftype Num

Procedure setValue(dataIn isoftype in Number)

value <- dataIn

endprocedure // setValue

Function getValue returnsa Num()

getValue returns value

endfunction // getValue

Procedure Initialize()

value <- 0

endprocedure // Initialize

endclass // Simple

LB

Once Written, It’s Easy!

Once we’ve written the class…• We test it and validate that it works• We can then make use of it in any

algorithm• Notice in the following algorithm

examples how little work is done– All manipulation is hidden from

the algorithm– All the “details” are abstracted

into the object

Airplane Example

An Airplane knows how to:• Take off• Land• Fly to a destination (and serve a snack)• Change its altitude

It also has the following attributes• Current altitude• Whether it’s flying or not

Airplane Symbolic Diagram

Airplane

Initialize

TakeOff

ChangeAltitude• InTheAir

• AltitudeIsFlying

ServeSnackLand

Fly

class Airplanepublic

procedure TakeOff// comments here

procedure Land // comments here

procedure ChangeAltitude (NewHeight iot in Num)// comments herefunction IsFying returnsa boolean// comments hereprocedure Initialize// comments hereprocedure Fly (destination iot in String)// comments here

protected // create the persistent data

InTheAir isoftype BooleanAltitude isoftype Num

// still in the protected section procedure Initialize

InTheAir <- FALSEAltitude <- 0

endprocedure // Initialize

procedure TakeOff if InTheAir then

print("I'm in the air!") else

InTheAir <- TRUE ChangeAltitude(3000)

endifendprocedure // TakeOff

// still in the protected sectionprocedure ChangeAltitude (NewHeight iot in Num) Altitude <- NewHeightendprocedure // ChangeAltitude

procedure Fly (destination iot in String) print(“I’m flying to”, destination) ServeSnack endprocedure // Fly

procedure ServeSnack// comments here

MAKE PASSENGERS HAPPYendprocedure // ServeSnack

// still in the protected sectionfunction IsFlying returnsa boolean

IsFlying returns InTheAirendfunction // IsFlying

procedure Land if InTheAir then

InTheAir <- FALSE ChangeAltitude(0)

else print("I'm not in the air!")

endif endprocedure // Land

endclass // Airplane

Using the Airplane Class

algorithm Airportuses Airplane

Cessna1090 isoftype Airplane

Cessna1090.InitializeCessna1090.TakeoffCessna1090.ChangeAltitude(30000)

Cessna1090.Fly(“Baltimore”) Cessna1090.Landendalgorithm

The Queue

A collection with restricted set of operations to change its state: only modified by adding to one end and deleting from the other.

Enqueue

Dequeue

NumberQueue Symbolic Diagram

NumberQueue

Initialize

Enqueue

Dequeue

• head

• tail

IsEmpty

…

IsFull

class NumberQueuepublic procedure Enqueue(value iot in Num) // contract information here procedure Dequeue(value iot out Num) // contract - queue not empty procedure Initialize // contract information here function IsEmpty returnsa Boolean // contract information here function IsFull returnsa Boolean // contract information here

protectedList_type definesa record data isoftype Num next isoftype Ptr toa List_typeendrecord

// create the persistent data head, tail isoftype Ptr toa List_type

// still in the protected section

procedure Enqueue(value iot in Num)

temp isoftype Ptr toa List_type

temp <- new(List_type)

temp^.data <- value

temp^.next <- NIL

if(IsEmpty) then

head <- temp

else

tail^.next <- temp

endif

tail <- temp

endprocedure // Enqueue

// still in the protected section procedure Dequeue (value iot out Num) if(IsEmpty) then

// violates contract! Error! else

value <- head^.data head <- head^.next if(IsEmpty) then

tail <- NIL endif

endif endprocedure // Dequeue

// still in the protected section function IsEmpty returnsa Boolean IsEmpty returns (head = NIL)endfunction // IsEmpty

function IsFull returnsa Boolean IsFull returns FALSE // dynamicendfunction // IsFull

procedure Initialize // initialize the persistent data head <- NIL tail <- NILendprocedure // Initialize

endclass // NumberQueue

algorithm Store uses NumberQueue temp isoftype num

checkout isoftype NumberQueuecheckout.Initialize

. . .loop

some people enter and leave store randomly exitif ((no people in store) AND (closing_time)) if (someone walks up for service) then checkout.Enqueue(person’s number) endif if (NOT checkout.IsEmpty) then checkout.Dequeue(temp) print(“Now servicing person”, temp) endif endloopendalgorithm // Store

Example: Simulating the Lotto

• We want to define a class that will allow us to simulate the lottery.

• We want to place elements into random locations in the collection.

• When we get an item from the collection, we want a random element.

A “Pile” Class

• A data structure in which– Items are inserted somewhere

randomly in the middle of the structure

– Items are removed from a random location in the structure

Pile Symbolic Diagram

NumPile

Initialize

StickOn

DigOut

• Head

• num_of_things

IsEmpty Random

…

class NumPilepublicprocedure StickOn (the_thing iot in Num)// purpose: put an item on the pile.

// pre: none // post: the pile has the item added to it

procedure DigOut (the_thing iot out Num)// purpose: get an item off of the pile.// pre: the pile is not empty.// post: the pile has a random element// removed.

function IsEmpty returnsa boolean // comments here - contractprocedure Initialize

// comments here - contract

protectedPileNode definesa Record

thing isoftype Numnext isoftype ptr to PileNode

endrecord // PileNode

head isoftype ptr toa PileNodenum_of_things isoftype Num

procedure Initialize

num_of_things <- 0

head <- NIL

endprocedure // Initialize

function IsEmpty returnsa boolean IsEmpty returns (head = NIL) endfunction // IsEmpty

// still in the protected sectionfunction Random returnsa Num // returns a random number <=

// num_of_thingsendfunction // Random

procedure StickOn (thing isoftype in Num) place_to_insert isoftype Num place_to_insert <- Random new_node isoftype ptr toa PileNode new_node <- new(PileNode)

// loop through pile until place-to- // insert is reached, then insert node

num_of_things <- num_of_things + 1endprocedure // StickOn

// still in the protected section

procedure DigOut (thing isoftype out Num)

thing_to_snag isoftype Num

place_to_get isoftype Num

place_to_get <- Random

// code for looping through pile to

// find right thing-to-snag, then

// remove it

num_of_things <- num_of_things - 1

thing <- thing_to_snag

endprocedure // Dig-Out

endclass // NumPile

Using the Pile Classalgorithm Lotto uses NumPile

lotto_pile isoftype NumPilelotto_pile.Initializeticket isoftype Numloop

exitif (All Entries Purchased)Get_Entry(ticket) // get input from userlotto_pile.StickOn(ticket)

endloop

// Now, find one winner lotto_pile.DigOut(ticket)print ("The winning number is", ticket)

endalgorithm // Lotto

Summary

• Writing classes involves considerable work in – Design, Implementation, & Testing

• But once done, algorithms may make use of the classes– Instantiating objects and

manipulating them– Hiding the details and implementation– Much of the work is done inside the

object

Questions?

Copy vs. Clone

The Scenario

• Imagine we have an object of type Queue

• We’d like to duplicate the contents of the object

• The assignment operator (<-) duplicates variables

• How do we duplicate objects?

Representing Objects

• Objects may have static and dynamic components.

q_head q_tail

11 13 \\9

MyNumQueue

Shallow vs. Deep Duplication

Copy performs a shallow duplication – duplicating only the static data.

Cloning performs a deep duplication – duplicating the static and dynamic data (i.e. following pointers into the heap and duplicating the heap data)

Create Two Objects

MyNumQueue isoftype Queue(Num)

YourNumQueue isoftype Queue(Num)

// do some work to fill in MyNumQueue

q_head q_tail

MyNumQueue

q_head q_tail

\\

YourNumQueue

\\11 13 \\9

Copying an Object

YourNumQueue <- copy(MyNumQueue)

q_head q_tail

MyNumQueue

q_head q_tail

YourNumQueue

11 13 \\9

Risk of Copying an Object

YourNumQueue.Enqueue(42)

q_head q_tail

\\

MyNumQueue

q_head q_tail

YourNumQueue

42 11 13 9

Risk of Copying an Object

MyNumQueue.Enqueue(31)

q_head q_tail

\\

MyNumQueue

q_head q_tail

YourNumQueue

42

\\31

11 13 9

Create Two Objects

MyNumQueue isoftype Queue(Num)

YourNumQueue isoftype Queue(Num)

// do some work to fill in MyNumQueue

q_head q_tail

MyNumQueue

q_head q_tail

\\

YourNumQueue

\\11 13 \\9

Cloning an Object

YourNumQueue <- clone(MyNumQueue)

- or –

YourNumQueue <- MyNumQueue

q_head q_tail

11 13 \\9

MyNumQueue

q_head q_tail

YourNumQueue

11 13 \\9

Summary

• Duplication of objects:– Shallow: only duplicate static memory– Deep: duplicate static and dynamic memory

• Copy is shallow duplication• Clone is deep duplication

• Assignment operation on objects is clone

Questions