ECS140A Programming Languages 13-1

Transcription

1 Data Abstraction in Ada purpose: learn about kinds of things want to do with data abstractions, not just to learn Ada. Primary data abstraction mechanisms in Ada is the package similar in some ways to Modula-2 s module, but more powerful serves several roles Wespoke already about roles of modules: subroutine library data structure and operations on that data abstract data type. We ll see these and others in Ada packages. ECS140A Programming Languages 13-1

2 ASubroutine Library Package package plot is type point is record x,y:float; end record; procedure move_to(location:point); procedure line(from, to:point); procedure circle(center:point; radius:float) function where return point; end plot; package body plot is procedure move_to(location:point) is end plot; -- user: use plot; -- like Modula-2 s from import a,b:point; a:=(3.2, 4.8); -- note the record assignment. move_to(a); circle(a,.25) AShared Data Package (like Fortran COMMON) package token_info is token: array (1..100) of character; internal_rep: integer; end token_info; -- note: no body needed: nothing to implement. -- user: use token_info; while internal_rep /= end_of_file loop end loop; ECS140A Programming Languages 13-2

3 Package Encapsulating a Data Structure and Operations Thereon package stack1 is procedure pop(x: out integer); procedure push(x: in integer); function empty return boolean; end stack1; package body stack1 is store: array(1..100) of integer; top: integer range := 0; -- initialization. procedure pop(x: out integer); if empty() then else x:=store(top); top := top 1; endif; end pop; procedure push(x: in integer) is end push; function empty return boolean is return top = 0; end empty; end stack1; -- use use stack1; push(3); push(10); pop(x); -- or, without use stack1.push(3); stack1.push(10); stack1.pop(x); ECS140A Programming Languages 13-3

4 Package Providing an Abstract Data Type could define another Ada stack this way, i.e., stack as type. package stack_type type stack is private; procedure createstack(out s:stack); procedure push( in out s:stack; in x:integer);. private type stack is record store: top : end record; end stack_type; package body stack_type procedure createstack(out s:stack) is end stack_type; -- user use stack_type; s1, s2:stack; createstack(s1); createstack(s2); push(s1,3); push(s2, 44); contrast with Modula-2 approach. tradeoffs? ECS140A Programming Languages 13-4

5 Another example of an ADT package complex_type is type complex isprivate; -- like Modula-2 s opaque. I: constant complex; -- I is a deferred constant; -- its value depends on representation; hence it is hidden. function + (x,y:complex) return complex; function - (x,y:complex) return complex; function * (x,y:complex) return complex; function / (x,y:complex) return complex; function REAL (x:complex) return float; function IMAG (x:complex) return float; function + (x:complex; y:float) return complex; function + (x:float; y:complex) return complex; private type complex isrecord real, imag:float := 0.0; end record; I: constant complex :=(0.0,1.0); end complex_type; Note that even though complex and I are d to be private, their definitions appear in the specification. They are not visible, though. Why does Ada do this? Contrast to Modula-2. Note that + is heavily overloaded. Can we overload =? :=? Why might such be useful? Can we define the complex constant 1 in Ada? package body complex_type is function + (x,y:complex) return complex; return (x.real+y.real,x.imag+y.imag); end + ; function REAL (x:complex) return float; return x.real; end REAL; function + (x:complex; y:float) return complex; return (x.real+y,x.imag); end + ; end complex_type; ECS140A Programming Languages 13-5

6 -- use use complex_type; x,y,z: complex; x:= *I; -- note: x := 1.8; is not legal. y:=x+2.2; z:=x*y; ECS140A Programming Languages 13-6

7 Generic Package Motivation: consider stack1 package. What if we want two stacks in our program? Need to repeat it? Idea: define template for stack. In Ada, done using generic package. generic package stack is procedure pop(x: out integer); procedure push(x: in integer); function empty return boolean; package body stack is -- identical to body for stack1. -- use package s1 is new stack; -- instantiate a stack. package s2 is new stack; -- instantiate another stack. s1.push(3); s1.push(10); s2.push(44); s2.push(11); s1.pop(x); s2.push(x); Can t use use since push by itself would be ambiguous. Note: cannot dynamically instantiate a new stack in Ada other than by instantiating a procedure that contains a declaration of a new stack. I.e., cannot use new as a program statement as is done for allocating records. Other language, such as Simula-67, SmallTalk, and C+ +, allow fully dynamic instantiation. ECS140A Programming Languages 13-7

8 Parameterizing a Generic Package Motivation: want stacks of different sizes, or stack of integers and stack of characters. Idea: How dosuch stacks differ? Abstract out the differences. generic length: natural := 100; -- default value if not explicitly specified package stack is procedure pop(x: out integer); procedure push(x: in integer); function empty return boolean; package body stack is store: array (1..length) of integer; note use of generic parameter top: integer range 0..length := 0; note use of generic parameter -- rest is identical to body for stack1 -- but with 100 replaced by length. -- use package s1 is new stack(40); -- instantiate a stack, 40 elements. package s2 is new stack; -- instantiate a stack, 100 elements. ECS140A Programming Languages 13-8

9 Let s now parameterize the type: generic length: natural := 100; -- default value if not explicitly specified type element is private; package stack is procedure pop(x: out element); -- note changes here procedure push(x: in element); function empty return boolean; package body stack is store: array (1..length) of element; note use of generic parameter top: integer range 0..length := 0; note use of generic parameter -- rest is identical to body for above stack -- but with integer replaced by element. -- use package s1 is new stack(40,character); -- instantiate a stack, 40 characters. package s2 is new stack(integer); -- instantiate another stack, 100 integers. y: character; s1.push( d ); s2.push(3); -- or, use as package s1 is new stack(40,character); -- instantiate a stack, 40 characters. package s2 is new stack(integer); -- instantiate another stack, 100 integers.. use s1, s2; y: character; push(3); push( a ); -- unambiguous by context. if s1.empty() then -- must qualify to avoid ambiguity. ECS140A Programming Languages 13-9

10 saw two ways to provide abstractions, as we did in Modula-2 examples: module (first stack) type (second stack) Also saw two ways to associate operations associated with ADT. instance-specific, i.e., associate each instance of type. as in second stack (and generic stack) e.g., s1.push(3) general, i.e., not associated with instance of type. e.g., in complex_type example. useful because allows operators that deal with more than one instance, such as: = on stacks, + on complex. also in Ada, can dynamically allocate many objects of type stack because it is a type (record) not a package. Compiler complications overloaded procedures need context; can be messy in general. generic procedure brute force: one for each type. share code: if same size. ECS140A Programming Languages 13-10