1 / 30

Understanding Reference Assignment in Programming

This lecture delves into references, assignments, and dynamic models, focusing on garbage collection, classes, and the effects of assignments on linked elements. It provides exercises on reversing linked lists and discusses the complexities of reference assignment. Practical advice and variants of assignment and duplication are also covered.

derron
Download Presentation

Understanding Reference Assignment in Programming

An Image/Link below is provided (as is) to download presentation Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author. Content is provided to you AS IS for your information and personal use only. Download presentation by click this link. While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server. During download, if you can't get a presentation, the file might be deleted by the publisher.

E N D

Presentation Transcript

  1. Einführung in die ProgrammierungIntroduction to ProgrammingProf. Dr. Bertrand Meyer Lecture 12: More on references and the dynamic model

  2. Purpose of this lecture • Few really new concepts, but gain a better understanding of the tricky matter of references • Reminder on garbage collection and associated concepts

  3. p Assignment • Replaces a value by another x 0 2 p.set_coordinates(2, 1) y 1 0

  4. Setting fields (in routines of the class) • class • POSITION • feature–– Access • x: REAL • -- Horizontal position • y: REAL • -- Vertical position • feature–– Element change • set_coordinates(xval, yval: REAL) • -- Set coordinates to(`xval', `yval'). • require • x_positive: xval >= 0 • y_positive: yval >= 0 • do • ensure • x_set: x = xval • y_set: y = yval • end • end x :=xval y :=yval

  5. Effect of an assignment SeeLINKABLE in EiffelBase • Reference types: reference assignment • Expanded types: value copy item right 3 class LINKED_CELL feature item: INTEGER right:LINKED_CELL set_fields(n: INTEGER ; r: LINKED_CELL) -- Reset both fields. do item := n right := r end end  t 0 25 u 0 item := n right := r t, u: LINKED_CELL create t ;create u t.set_fields (25, u) t.set_fields (25, u)

  6. : inserting at the end A linked list of strings 3 4 count right item last_element first_element Parade-platz active (LINKABLE) Haupt-bahnhof Haldenegg Central right item right right item item (LINKABLE) (LINKABLE) (LINKABLE)

  7. Inserting an item at the end • extend (v: STRING) • -- Add v to end. • -- Do not move cursor. • local • p: LINKABLE [STRING] • do • create p.make (v) • if is_empty then • first_element := p • active := p • else • last_element.put_right (p) • if after then active := p end • end • last_element := p • count := count + 1 • end

  8. Exercise (uses loops) • Reverse a list! (LINKED_LIST) 3 count last_element first_element Haupt-bahnhof Parade-platz Halden-egg Central item right (LINKABLE)

  9. Reversing a list 1 2 3 4 5 1 2 3 4 5

  10. Reversing a list • from • pivot := first_elementfirst_element:=Void • untilpivot = Voidloop • i :=first_element • first_element:= pivot • pivot := pivot.right • first_element.put_right(i) • end 1 2 3 4 5 right first_element pivot i

  11. Reversing a list • from • pivot := first_elementfirst_element := Void • untilpivot = Voidloop • i :=first_element • first_element:= pivot • pivot := pivot.right • first_element.put_right(i) • end 1 2 3 4 5 right first_element pivot i

  12. Reversing a list • from • pivot := first_elementfirst_element := Void • untilpivot = Voidloop • i :=first_element • first_element:= pivot • pivot := pivot.right • first_element.put_right(i) • end 1 2 3 4 5 right first_element pivot i

  13. Reversing a list • from • pivot := first_elementfirst_element := Void • untilpivot = Voidloop • i :=first_element • first_element:= pivot • pivot := pivot.right • first_element.put_right(i) • end 1 2 3 4 5 right first_element pivot i

  14. Reversing a list • from • pivot := first_elementfirst_element := Void • untilpivot = Voidloop • i :=first_element • first_element:= pivot • pivot := pivot.right • first_element.put_right(i) • end 1 2 3 4 5 right pivot first_element pivot i i

  15. The loop invariant • from • pivot := first_elementfirst_element := Void • untilpivot = Voidloop • i :=first_element • first_element:= pivot • pivot := pivot.right • first_element.put_right(i) • end 1 2 3 4 5 right first_element pivot i Invariant: from first_elementfollowing right, initial itemsin inverse order; from pivot,rest of items in original order

  16. The trouble with reference assignment • A comfortable mode of reasoning: -- HereSOME_PROPERTYholds of a “Apply SOME_OPERATIONto b” -- Here SOME_PROPERTYstill holds ofa • This applies to “expanded” values, e.g. integers -- HereP (a) holds OP (b) -- HereP (a) still holds ofa

  17. Dynamic aliasing • a, b: LINKABLE [STRING] • create a.... • a.put("Haldenegg")‏ • b := a • -- Herea.itemhas value"Haldenegg" • b.put("Paradeplatz")‏ • -- Herea.itemhas value ????? b a Haldenegg right item

  18. On the other hand... • -- I heard that the boss’s cousin earns less • -- than 50,000 francs a year • “Raise Caroline’s salary by 1 franc” • -- ????? • Metaphors: • “The beautiful daughter of Leda” • “Menelas’s spouse” • “Paris’s lover” = Helen of Troy

  19. Practical advice • Reference assignment is useful • It’s also potentially tricky • As much as possible, leave it to specialized libraries of general data structures

  20. Variants of assignment and copy • Reference assignment (a and b of reference types): b := a • Object duplication (shallow): c := a.twin • Object duplication (deep): d := a.deep_twin • Also: shallow field-by-field copy (no new object is created): e.copy (a)‏

  21. Shallow and deep cloning a • Initial situation: • Result of: b:=a c := a.twin • d := a.deep_twin O1 name “Almaviva” landlord loved_one O3 O2 “Figaro” “Susanna” b O4 “Almaviva” c d “Almaviva” O5 O7 O6 “Figaro” “Susanna”

  22. Where do these mechanisms come from? • Class ANY in the Eiffel “Kernel Library” • Every class that doesn’t explicitly inherit from another is considered to inherit from ANY • As a result, every class is a descendant of ANY.

  23. B C D E Completing the inheritance structure ANY A Inheritsfrom NONE

  24. A related mechanism: Persistence Needs to be improved, see “ “object test” a.store (file)‏ .... b := retrieved(file) • Storage is automatic. • Persistent objects identified individually by keys. • These features come from the library class STORABLE.

  25. Objects and references • States of a reference: • Operations on references: createp p := q p := Void ifp = Voidthen... createp p := q(where q is attached)‏ p ATTACHED VOID ATTACHED p VOID p := Void p := q(where q is void)‏

  26. The object-oriented form of call • some_target.some_feature (some_arguments)‏ • For example: • Paris.display • Line6.extend (Station_Parade_Platz)‏ • x := a.plus (b)???????

  27. Infix and prefix operators • In • a − b • the − operator is “infix” (written between operands)‏ • In • − b • the − operator is “prefix” (written before the operand)‏

  28. Operator features • expanded class INTEGERfeature • plus alias"+" (other : INTEGER): INTEGER • -- Sum with other • do ... endtimes alias“*“ (other : INTEGER): INTEGER • -- Product by other • do ... endminus alias“-" : INTEGER • -- Unary minus • do ... end • ... • end • Calls such as i.plus (j) can now be written i+ j

  29. Reading assignment for next week • Chapters on • Syntax (11) • Inheritance (16)

  30. Playing with references: list reversal • Dynamic aliasing and thedifficulties of pointers &references • Overall inheritance structure • Copy, clone and storage operations • Persistence closure • Infix & prefix operators What we have seen

More Related