Control flow in Eiffel

Transcription

1 Announcements Assignment will be posted this week.» We ll make sure you have enough time to it! A little more Eiffel, Genericity and ADTs Week 3, Lecture 4 January 16 Section N Review What is the definition of object? What is aliasing? What is the difference between a reference type and an expanded type? How equal and twin differ from deep_equal and deep_twin?» are these identifiers keywords in the Eiffel language? Exercise (to try another time)» draw some data structure, such as of the PERSON object we saw last lecture, and then draw twins s and deep_twins s of them. Control flow in Eiffel

2 If.. then.. elseif.. else.. if Multi-way selection if condition 1 then block 1 elseif condition 2 then block 2 elseif condition 3 then block 3 else block n inspect expression when expression to test equality then block when then block else -- this is like default: default: in Java and C/C++. block Example: inspect x + y when 0 then when 1,2,20 then when 5..8 then when , then else print( Not 0, 1, 2, 5..8, , 20, or %N ) from until block -- initialization condition -- stopping criteria invariant loops assertion -- loop invariant; can work without. variant loop assertion -- loop variant; can work without. block -- body loop feature {ALL public static final not! Constant_One : INTEGER is 32 Constant_Two : BOOLEAN is True Constant_Three : DOUBLE is (to define constants, it s s best to stick them into a class called CONSTANTS or GLOBAL_CONSTANTS, and inherit that class)

3 Expressions: and then, or else Conditional Expressions» and, or, not, xor,, implies, and then, or else. what s s wrong with: feature use_dadaism( s:string ) is if s.equals( dadada dadada ) then print( It It s s dadaism, alright!%n )» hint: s is of a reference type. What are s s possible values? solution #1: Expressions: and then, or else feature use_dadaism( s:string ) is if s /= Void then if s.equals( dadada dadada ) ) then print( it it s s dadaism, alright! %N ) solution #2: Expressions: and then, or else feature use_dadaism( s:string ) is if s /= Void and then s.equals( dadada dadada ) print( it it s s dadaism, alright! %N )» x and then y > evaluate x for truth. If it s s true, then evaluate y.» x or else y > evaluate x for truth. If it s s false, then evaluate y. then A check clause Simple assertions (a standard assertion) check test_array.count = 3

4 A note on inheritance: redefinition If your class EH has features called setup and tearwn, and you want class BEE to redefine (i.e. override) them, here s how to write your class BEE: class BEE inherit EH redefine setup, tearwn feature {ANY setup is tearwn is Identifiers» class names must be capitals > BOOLEAN, PERSON Style» feature names must be lowercase, with underscores for spaces _ > make_from_array,, has, put, is_equal make them as terse as possible. Try to use feature names you ve seen in other classes.» constants are capitalized and lowercase: > Void, True, False, Constant_one,, Filename Indentation style indexing description: [ ] status: date: $Date 2005/16/05 class ARRAY [G] inherit RESIZABLE [G] redefine full, copy, is_equal Style create make, make_from_array feature -- initialization make( min_index, max_index: INTEGER ) is -- Allocate array; set interval to -- min_index.. max_index ; require valid_bounds: min_index <= max_index + 1 lower := min_index if min_index <= max_index then make_area( max_index min_index + 1 ) else make_area(0) Comments:» terse, terse, terse. Must fit on a printed page easily. Genericity

5 A world without genericity Problem: Classes such as STACKs s need to be able to operate on different kinds of objects. One solution: make sure the class is defined in terms of a high-level class, such as ANY. Glory of Java without Genericity public class Stack { private int count; private int capacity; private int capacityincrement; private Object[] itemarray; // instead of ARRAY[G] Stack() { //constructor limited to class name count= 0; capacity= 10; capacityincrement= 5; itemarray= new Object[capacity]; public boolean empty() { return (count == 0); Glory of Java without Genericity public void push(object x) { if(count == capacity) { capacity += capacityincrement; Object[] temparray= new Object[capacity]; for(int i=0; i < count; i++) temparray[i]= itemarray[i]; itemarray= temparray; itemarray[count++]= x; public Object pop() { if(count == 0) return null; else return itemarray[-- --count]; Glory of Java without Genericity public Object peek() { if(count == 0) return null; else return itemarray[count-1]; public class Point { public int x; public int y;

6 Glory of Java without Genericity class teststack { public static void main(string[] args) ) { Stack s = new Stack(); Point upperright = new Point(); upperright.x= 1280; upperright.y= 1024; s.push("red"); s.push("green"); // push some String s.push("blue"); // objects on the stack. s.push(upperright upperright); // push a POINT object on the stack while(!s.empty()) { String color = (String) s.pop(); // System.out.println println(color); // cast all items from OBJECT // to STRING in order to print. // What s s wrong with that? causes a run-time error: ClassCastException: Point at teststack.main(teststack.java:18) Does run-time vs.. compile time matter? When flying a plane, run-time is too late to find out that you n t t have landing gear!» Always better to catch errors at compile time! This is the purpose of Strong Typing [OOSC2, Chapter 17]. A compiler for a strongly-typed typed language performs some verification of program correctness!» if you can catch it at compile time instead of runtime, you ll eliminate a whole set of possible run-time errors.» so, we try as much as possible to catch things at compile-time. Genericity helps to enforce Strong Typing, i.e. by ensuring no runr un-time typing errors.» LIST[INTEGER INTEGER]» LIST[BOOK BOOK]» LIST[STRING STRING] Generic Class A generic class is a class that is parameterized by type class ARRAYED_LIST [G] inherit ARRAY [G] rename force as force_i_th, item as array_item, infix "@" as array_infix_at, On object declaration the parameter is assigned a type» For example catalogue : ARRAY [ PERSON ]» We want an array of references to persons» All the array operations for catalogue are customized to use persons Common Generic Classes Collection classes classes that are collections of objects» Strong typing requires specifying a type» But feature semantics is indepent of type Works when feature semantics is common to a set of types.» e.g. if objects are all COMPARABLE and thus support the features: >, >=, <=, <, etc. Examples» Sets, Stacks, Arrays, Queues, Sequences a : ARRAY [ MATRIX_ELEMENT ] a : ARRAY [ INTEGER ] a : ARRAY [ STACK [ ELEPHANTS ]

7 Your Generic Classes You can write generic classes Why is this useful?» reuse» reliability We need Understanding Genericity» lists of INTEGER, lists of BOOK, lists of STRING etc. Without genericity we have» INTEGER_LIST, BOOK_LIST, STRING_LIST Problem Reusability.» The basic operations (e.g. add, remove) ) are essentially the same.» Have to re-write essentially the same code over and over again.» Violation of the Single Choice Principle changing LIST requires multiple changes, instead of a change at a single point.[meyer, p63]. Will go over this again in next lecture. Generic Stack Generic Array class STACK [ G ] feature count : INTEGER -- number of elements empty : BOOLEAN is... full : BOOLEAN is... item : G is... put ( x : G ) is... remove is STACK class ARRAY [ P ] creation make feature make ( minindex, maxindex : INTEGER ) is... lower, upper, count : INTEGER put ( value : P ; index : INTEGER ) is... item alias [], (i:integer): P is ARRAY Can use parameter G wherever a type is expected

8 Using the Generic Array circus : ARRAY [ STACK [ ELEPHANTS ] ] create circus.make ( 1, 200 ) st_el : STACK [ ELEPHANTS ] -- element to put in the array create st_el circus.put ( st_el, 30 ) -- put an element into the array st_el2 : STACK [ ELEPHANTS ] Types» Unconstrained» Constrained Types of Genericity The previous examples showed unconstrained genericity» Any type could be passed as a parameter. (i.e. a type that inherits ANY could be passed as a parameter.) st_el2 := get an element from the array st_el2 := circus[101] -- alternative notation Constrained Genericity Used when the generic type parameters must satisfy some conditions The following makes sense only if P has the feature Constrained Genericity Used when the generic type parameters must satisfy some conditions The following makes sense only if P has the feature class VECTOR [ P ] feature... minimum ( x, y : P ) : P is if x y then Result := y else Result := x... How we enforce constraints is discussed in Inheritance Techniques class VECTOR [ P->COMPARABLE ] feature... minimum ( x, y : P ) : P is if x y then Result := y else Result := x...

9 Discussion on Genericity What programming languages offer genericity that you know of? Java? C++? Other? C++ has the template: Set < int > s ; Java 5 has added genericity What is the effect of genericity on» compile time» size of the generated code» execution time» execution space Warning: : generics cheap in Eiffel expensive in C++ Abstract Data Types What is an abstract data type? You re computer scientists and engineers, so you already know what an ADT is.» So? Definition: Abstract Data Type Definition: Abstract Data Type a set of mathematical elements specified by listing the functions applicable to all these elements and the formal properties of these functions Formal properties: pre- and post-conditions, or preconditions and axioms.» later on, we ll just focus on pre- and post-conditions. [Meyer, Ch.6] (but this focusses only on preconditions and axioms)

10 What s s in an ADT definition? 1) A declaration of the ADT:» let STACK[G] be an abstact data type, where G is any arbitrary abstract data type. 2) A declaration of the set of functions that operate on the ADT:» put: STACK[G] G STACK[G]» remove: STACK[G] STACK[G]» item: STACK[G] G» is_empty: STACK[G] BOOLEAN» make: STACK[G] What s s in an ADT definition? 3) A declaration of the preconditions for each function:» put (s:stack[g]; t: G): STACK[G] require: : True» remove (s: STACK[G]): STACK[G] require: is_empty(s)» item (s: STACK[G]): G require: is_empty(s)» make: STACK[G] require: : True» is_empty( s: STACK[G]): BOOLEAN require: : True What s s in an ADT definition? 4) A declaration of axioms: For any x, x 1, x 2 : G, s: STACK[G],» item ( put (s,x)) = x» remove ( put (s,x)) = s» is_empty (make)» is_empty( put (s,x) ) Now we can talk about theorems:» is_empty( s ) = ( remove( put( s, x ) ) = make )» is_empty( remove( remove( put( put( make, x 1 ), x 2 ) ) ) )» item( put( put( s, x ), x 2 ) ) = x 2 (but we won t t for the rest of the course!!!) From an ADT to objects If we add implementation details, we can remove the axioms and add postconditions that describe what effect the objects have. e.g.» put (s:stack[g]; t: G): STACK[G] require: : True ensure: : not is_empty(s)» make: STACK[G] require: : True ensure: is_empty(result Result) Syntactic sugar:» s = put(s, t) becomes s.put(t)» is_empty(s) becomes s.is_empty

11 Next Class Topics» TDD and ESpec.» Some more aspects of inheritance and DbC.