OOP Lecture - 19 February 1996

Lecture of 19 February 1996

Reading Assignment

Read pages 103-134 in Budd.

Case Study: Eight Queens

Budd uses technique of delegating responsibility to an aggregate object (in this case a neighboring queen).
Each queen considers he position only with regard to her neighbor on one side. This leads naturally to a linear structure.
How does Budd terminate the linear structure? What can you do in languages that support pointers? What can you do in languages without pointers?
The technique involved in Budd's program using generating and filtering.
Queens are numbered by the column in which they reside.
first-position attempts to generate an initial solution for a queen and all her lower numbered neighbors.
test-or-advance checks the current position for feasibility and either returns true to indicate it satisfies the test or returns the result of generating the next feasible solution.
check-row checks a row and column position against a particular queen to see if the queen or any of her lower numbered neighbors can attack that position.
next-position attempts to generate the next feasible solution for a queen and all her lower numbered neighbors.

Dylan Eight-Queens Example

module: dylan author: Joseph N. Wilson copyright: 1996 Joseph N. Wilson description: Dylan example of the eight queens program strategy employed by Budd in Chapter 5 of his book *An Introduction to Object-Oriented Programming*. define class <queen> (<object>) slot row :: <integer>; slot column :: <integer>, init-keyword: column:; slot neighbor :: <queen>, init-keyword: neighbor:; end class <queen>; define method first-position (q :: <queen>) => <boolean>; // // Finds the first unattacked board configuration for queen q. // if (first-position (q.neighbor)) q.row := 1; test-or-advance (q); else #f; end if; end method first-position; define method test-or-advance (q :: <queen>) => <boolean>; // // Tries to insure that Queen q's position is not attacked. // If current position is unattacked, returns #t. // Otherwise it attempts to get to next board configuration and // returns value given by next-position. // if (check-row (q.neighbor, row: q.row, col: q.column)) next-position (q); else #t; end if; end method test-or-advance; define method check-row (q :: <queen>, #key row: r, col: c) => <boolean>; // // Checks to see if Queen q or any of her neighbors can attack position // given by keyword parameters row: col: // // Returns #t if position can be attacked, #f otherwise. // if (r = q.row) #t; else let cd = q.column - c; if (q.row + cd = r | q.row - cd = r) #t; else check-row (q.neighbor, row: r, col: c); end if; end if; end method check-row; define method next-position (q :: <queen>) => <boolean>; // // Tries to modify the board to get the next unattacked board // configuration for queen q. // // Returns #t if it succeeds. // Returns #f if no more unattacked positions exist. // block (exit) if (q.row = 8) if (~ next-position (q.neighbor)) exit (#f); else q.row := 0; end if; end if; q.row := q.row + 1; test-or-advance (q); end block; end method next-position; define method print-board (q :: <queen>) princ (q.column); princ (' '); for (i from 1 below q.row) princ (". "); end for; princ ("Q "); for (i from q.row + 1 to 8) princ (". "); end for; print (""); print-board (q.neighbor); end method print-board; define method print (q :: <queen>) print (q.neighbor); princ (q.row); princ (" "); print (q.column); end method print; // // Class <null-queen> is used to terminate the recursive structure // employed in <queen> // define class <null-queen> (<object>) end class <null-queen>; define method first-position (q :: <null-queen>) #t; end method first-position; define method next-position (q :: <null-queen>) #f; end method next-position; define method check-row (q :: <null-queen>, #key row: r, col: c) #f; end method check-row; define method print-board (q :: <null-queen>) end method print-board; define method print (q :: <null-queen>) end method print; define method queens () let last-queen = make (<null-queen>); for (i from 1 to 8) last-queen := make (<queen>, neighbor: last-queen, column: i); end; if (first-position (last-queen)) print-board (last-queen); print (last-queen); end if; end method queens;

Programming Assignment Due Wednesday 28 February

Modify the Dylan program to solve exercises 1 and 2 of page 84. Don't worry about filtering rotations.

Static and Dynamic Binding

Bindings of interest: variable to type and message to method
Type may be associated with a variable or a value or both.
An expression is type correct if it can be evaluated without any errors arising from objects belonging to classes without the methods required to carry out evaluation of the expression.
Languages in which it is possible to guarantee that all expressions are type correct before running the program are saod to be strongly typed.
If an OOP uses classes as types, then assignment of subclass objects to superclass variables introduces a new twist in this old problem.
The type of a variable (its static class) may not match the type of the value it denotes (its dynamic class). Consider the following Dylan fragment:
Explain the behavior of the interpreter in evaluating this sequence of constituents.

The Container Problem

Budd's example: class Ball with derived classes BlackBall and WhiteBall.
Make a ball container. Insert a ball. Is it a black ball or is it a white ball.
Without run time type information (RTTI) it is impossible to distinguish what kind of ball is contained within the container.
How would one define such a container in C++?
You've already seen a case of a container, namely, a button.