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 Altitude IsFlying ServeSnack Land Fly

class Airplane public procedure TakeOff // comments here procedure Land // comments here procedure ChangeAltitude (NewHeight iot in Num) // comments here function IsFying returnsa boolean // comments here procedure Initialize // comments here procedure Fly (destination iot in String) // comments here protected // create the persistent data InTheAir isoftype Boolean Altitude isoftype Num

// still in the protected section procedure Initialize InTheAir <- FALSE Altitude <- 0 endprocedure // Initialize procedure TakeOff if InTheAir then print("I'm in the air!") else InTheAir <- TRUE ChangeAltitude(3000) endif endprocedure // TakeOff

// still in the protected section procedure ChangeAltitude (NewHeight iot in Num) Altitude <- NewHeight endprocedure // ChangeAltitude procedure Fly (destination iot in String) print(“I’m flying to”, destination) ServeSnack endprocedure // Fly procedure ServeSnack // comments here MAKE PASSENGERS HAPPY endprocedure // ServeSnack

// still in the protected section function IsFlying returnsa boolean IsFlying returns InTheAir endfunction // 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 Airport uses Airplane Cessna1090 isoftype Airplane Cessna1090.Initialize Cessna1090.Takeoff Cessna1090.ChangeAltitude(30000) Cessna1090.Fly(“Baltimore”) Cessna1090.Land endalgorithm

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 NumberQueue public 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 protected List_type definesa record data isoftype Num next isoftype Ptr toa List_type endrecord // 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 endprocedure // Dequeue

// still in the protected section function IsEmpty returnsa Boolean IsEmpty returns (head = NIL) endfunction // IsEmpty function IsFull returnsa Boolean IsFull returns FALSE // dynamic endfunction // IsFull procedure Initialize // initialize the persistent data head <- NIL tail <- NIL endprocedure // Initialize endclass // NumberQueue

algorithm Store uses NumberQueue temp isoftype num checkout isoftype NumberQueue checkout.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 endloop endalgorithm // 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 NumPile public procedure 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 - contract procedure Initialize // comments here - contract

protected PileNode definesa Record thing isoftype Num next isoftype ptr to PileNode endrecord // PileNode head isoftype ptr toa PileNode num_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 section function Random returnsa Num // returns a random number <= // num_of_things endfunction // 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 + 1 endprocedure // 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 Class algorithm Lotto uses NumPile lotto_pile isoftype NumPile lotto_pile.Initialize ticket isoftype Num loop exitif (All Entries Purchased) Get_Entry(ticket) // get input from user lotto_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_headq_tail 1113 \\ 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_headq_tail MyNumQueue q_headq_tail \\ YourNumQueue \\ 1113 \\ 9

Copying an Object YourNumQueue <- copy(MyNumQueue) q_headq_tail MyNumQueue q_headq_tail YourNumQueue 1113 \\ 9

Risk of Copying an Object YourNumQueue.Enqueue(42) q_headq_tail \\ MyNumQueue q_headq_tail YourNumQueue

Risk of Copying an Object MyNumQueue.Enqueue(31) q_headq_tail \\ MyNumQueue q_headq_tail YourNumQueue 42 \\

Create Two Objects MyNumQueue isoftype Queue(Num) YourNumQueue isoftype Queue(Num) // do some work to fill in MyNumQueue q_headq_tail MyNumQueue q_headq_tail \\ YourNumQueue \\ 1113 \\ 9

Cloning an Object YourNumQueue <- clone(MyNumQueue) - or – YourNumQueue <- MyNumQueue q_headq_tail 1113 \\ 9 MyNumQueue q_headq_tail YourNumQueue 1113 \\ 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