Imperative programming

1. Imperative programming Name Binding Variable Data Type Type checking Type equivalence

2. Name • String ที่ใช้ในการกำหนดชื่อให้กับ entity ในโปรแกรมเพื่อเก็บข้อมูลและเรียกใช้ข้อมูลที่ต้องการ • ชื่อตัวแปร • ชื่อโปรแกรมย่อย • ชื่อค่าคงที่ ฯลฯ • กฎเกณฑ์ในการตั้งชื่อ • Maximum length • Special character • Case sensitive • Special word

3. Special words • Keyword : a word that is special only in certain contextsตัวอย่าง FORTRANREAL APPLE -> ประกาศตัวแปรประเภทจำนวนจริงREAL = 3.4 -> กำหนดค่าให้ตัวแปรชื่อ REALREAL INTEGERINTEGER REAL • Reserved word : a special word that cannot be used as a user-defined name

4. Binding • Binding : an association, such as between an attribute and an entity, or between an operation and a symbol.เป็นการเชื่อม (bind) ชื่อที่กำหนดและคุณสมบัติของชื่อ (attribute) เข้าด้วยกัน • Binding time : the time at which a binding takes places. • Language design time - bind operator symbol กับ operation • Language implementation time - bind fl. pt. type กับ representation • Compile time - bind variable กับ type • Load time - bind a variable กับ memory cell • Runtime - bind a nonstatic local variable กับ memory cell

5. Variable • Variable : an abstraction of a memory cell • มีคุณสมบัติ (attribute) 6 ประการ คือ Name, address, value, type, lifetime,scope • Name • Address : memory address ที่เก็บค่าของตัวแปร • ตัวแปรอาจมี address ที่ต่างกันในเวลาที่ต่างกันขณะ execution • ตัวแปรอาจมี address ที่ต่างกันเมื่อปรากฏอยู่คนละที่ในโปรแกรม • ถ้าตัวแปรสองตัวสามารถใช้ในการเข้าถึงตำแหน่งใน memory ตำแหน่งเดียวกัน จะเรียกว่า Alias

6. Variable (ต่อ) • Value : ค่าที่เก็บอยู่ใน address แบ่งเป็น • static variable เมื่อถูกกำหนดแล้ว จะทำให้รู้ขนาดโครงสร้างที่แน่นอนของตัวแปร • dynamic variable จะมีการขอเนื้อที่หน่วยความจำเมื่อต้องการใช้งานเท่านั้น ค่าที่บรรจุในตัวแปรจะเป็นตำแหน่งที่อยู่ของหน่วยความจำซึ่งเก็บข้อมูลที่ต้องการ student_ptr = ^student_rec; type student_rec = record id : string[10] name : string[30]; score : integer; end;var i : integer; student : array[1..30] of student_rec; next : student_ptr; student : student_ptr;

7. Variable (ต่อ) • Type : เป็นตัวกำหนด • ช่วงค่าของตัวแปร (range of values) • กลุ่มของตัวดำเนินการ (set of operations) • Lifetime : ช่วงเวลานับตั้งแต่ตัวแปรถูก bind เข้ากับ memory แบ่งเป็น • static - bind ก่อนจะเริ่ม execution (load time binding) • stack-dynamic - bind เมื่อมีการประกาศตัวแปรตัวนั้น (runtime binding) • explicit heap-dynamic - มีการ allocation หรือ deallocation โดยใช้คำสั่งโดยตรง • implicit heap-dynamic - มีการ allocation หรือ deallocation โดยใช้คำสั่งกำหนดค่า allocation - getting a cell from some pool of available cells deallocation - putting a cell back

8. Variable (ต่อ) • Scope : บริเวณหรือส่วนของโปรแกรมที่ตัวแปรที่กำหนดจะสามารถถูกเรียกใช้งานได้ หรือเรียกว่าโปรแกรมสามารถมองเห็น (visible) ได้เฉพาะตัวแปรที่อยู่ในขอบเขตที่กำหนด Monolithic block structure Program Example1; var x:integer; begin …. end. Declaration of x Block structure - เป็นโครงสร้างที่กำหนดขอบเขตการใช้งานของตัวแปรต่าง ๆ ที่ได้ถูกกำหนดไว้แล้ว

9. Variable (ต่อ) Flat block structure Program Example2; var x:integer; Procedure P; var y:integer; begin …. end; (*P*) begin …. end. Declaration of x Declaration of y Declaration of z

10. Variable (ต่อ) Nested block structure Program Example3; var x:integer; Procedure P; var y:integer; Procedure Q; var z:integer; begin … end; (*Q*) begin …. end; (*P*) begin …. end. Declaration of x Declaration of y Declaration of z

11. Data Types • การรวมกลุ่มค่าของข้อมูล (value) เข้าด้วยกัน เรียกว่าเป็นชนิดข้อมูล (Type) • โดยทั่วไป ภาษาโปรแกรมจะประกอบด้วยชนิดข้อมูล 2 ประเภท คือ • Primitive Type (Built-in Type) เป็นชนิดข้อมูลที่มีมาพร้อมกับภาษา ซึ่งมีการกำหนดการใช้เนื้อที่หน่วยความจำ ค่าที่เป็นไปได้ วิธีดำเนินการที่สามารถกระทำได้กับชนิดข้อมูลไว้แล้ว • integer 16 bit • value -215 .. (215-1) • operation + - * / Primitive type ชนิดเดียวกันอาจมีชื่อเรียกต่างกันไปในแต่ละภาษา • Pascal : integer , C : int

12. Data Types (ต่อ) • User Defined Type เป็นชนิดข้อมูลที่ผู้เขียนโปรแกรมสามารถกำหนดขึ้นใหม่ได้ • การตั้งชื่อชนิดข้อมูลที่มีอยู่แล้วขึ้นใหม่ (rename)TYPE int = integer;VAR a : int; • การกำหนดชนิดข้อมูลที่มีโครงสร้างใหม่ตามที่ต้องการTYPE status = (single, married, divorced) student_rec = RECORD id : string[10]; grade : real; END; class = array[1..40] of student_rec;VAR x : status; com, stat : class;

13. Data Types (ต่อ) • ประโยชน์ของ user defined type • ช่วยให้โปรแกรมอ่านง่าย เข้าใจง่าย (Readability)TYPE student_rec = RECORD id : string[10]; grade : real; END; student = student_rec class = array[1..40] of student;

14. Data Types (ต่อ) • สามารถเปลี่ยนแปลงแก้ไขได้ง่าย (Modifiability)TYPE student_rec = RECORD id : string[10]; grade : real; END; VAR student : student_rec;VAR student : RECORD id : string[10]; grade : real; END;

15. Data Types (ต่อ) Procedure P; var a: student_rec; begin ... end; Procedure Q; var b: student_rec; begin ... end; • สามารถนำไปใช้ซ้ำ ๆ กันได้ง่าย (Factorization)

16. Data Types (ต่อ) • ชนิดข้อมูลแบบมีโครงสร้าง (Composite Types หรือ Structure Data type หรือ Data aggregates) เป็นชนิดข้อมูลที่เกิดจากการนำค่าของข้อมูล Primitive Types มากระทำต่อกันด้วยวิธีการต่าง ๆ ดังนี้ • Cartesian Product (record) • Disjoint Unions (variant) • Mappings (array) • Powersets (set)

17. Cartesian products • การนำชนิดข้อมูลที่เหมือนหรือต่างกันมาคูณกัน • ผลลัพธ์ที่ได้จะเป็นชนิดข้อมูลใหม่ที่มีค่าของข้อมูลอยู่ในรูปคู่ลำดับ • สัญลักษณ์ S * T หมายถึง เซต S ทำ cartesian product กับเซต T ได้ผลลัพธ์เป็นคู่ลำดับ (x,y) S * T = { (x, y) ; x є S ; y є T } #(S * T) = #S * #T • ตัวอย่าง S = { u, v } T = { a, b, c } S * T = { (u,a), (u,b), (u,c), (v,a), (v,b), (v,c) } #(S * T) = 2 * 3 = 6

18. Cartesian products (ต่อ) • เราสามารถนำเซตมากกว่า 2 เซตมาทำ cartesian product ได้ T1 * T2 * ... * Tn = { (t1,t2,..,tn) ; t1є T1; t2є T2,.., tnє Tn } # (T1 * T2 * … * Tn)= #T1 * #T2 * … * #Tn • ชนิดข้อมูลแบบนี้ เช่น Record ใน Pascal, COBOL หรือ Struct ใน C, PL/I • RECORD field1 : type1; field2 : type2; … fieldn : typen;END;

19. Cartesian products (ต่อ) • TYPE month = (jan, feb, mar, apr, may, jun, jul, aug, sep, oct, nov, dec); date = RECORD m : month; d : 1..31; END; • { jan, feb, .. , dec } * { 1,2, .. , 31 }= { (jan,1), (jan,2), (jan,3), … , (jan,31), (feb,1), (feb,2), (feb,3), … ,(feb,31), … (dec,1), (dec,2), (dec,3), … ,(dec,31)} • จำนวนข้อมูล 12 * 31 = 372 คู่ลำดับ

20. Disjoint unions • การนำชนิดข้อมูลที่ต่างกันมารวมกัน • ผลลัพธ์ที่ได้จะเป็นชนิดข้อมูลใหม่ที่มีค่าของข้อมูลชนิดใดชนิดหนึ่ง • สัญลักษณ์ S + T หมายถึง เซต S ทำ disjoint union กับเซต T ได้ผลลัพธ์เป็นค่าของเซต S หรือ T เซตใดเซตหนึ่ง S + T = { left x / x є S} U {right y / y є T } #(S + T) = #S + #T • ตัวอย่าง S = { u, v } T = { a, b, c } S + T = { u, v, a, b, c } #(S + T) = 2 + 3 = 6

21. Disjoint unions (ต่อ) • ชนิดข้อมูลแบบนี้ เช่น Variant record ใน Pascal หรือ Unionใน C • RECORD field1 : type1; field2 : type2; … fieldn : typen; CASE tag : tag_type OF label1 : (fieldlist1); label1 : (fieldlist1); ... label1 : (fieldlist1);END;

22. fix part tag variant part currency exact int_val currency approx real_val Disjoint unions (ต่อ) • TYPE currency = ($,B) accuracy = (exact, approx) number = RECORDunit : currency; CASE acc : accuracy OF exact : (int_val : integer); approx : (real_val : real); END; • ค่าที่เป็นไปได้ของ number คือ{ …, exact(-2), exact(-1), exact(0), exact(1), exact(2), … } U{ …, approx(-1.0),..., approx(0.0),…, approx(1.0),… }

23. Mappings • การใช้ความสัมพันธ์แบบฟังก์ชันจากค่าของข้อมูลเซตหนึ่งไปยังค่าของข้อมูลอีกเซตหนึ่ง • จะทำให้ข้อมูลชนิดเดียวกันถูกรวบรวมเข้าด้วยกันเป็นกลุ่ม และสามารถเรียกใช้ได้ • สัญลักษณ์ S -> T หมายถึง การ map ค่าทุกค่าของเซต S ไปยังเซต T S -> T = { m / x є S => m(x) є T } #(S-> T) = (#T)#S • ตัวอย่าง S = { u, v } T = { a, b, c } S -> T = { u->a, v->a } { u->a, v->b } { u->a, v->c } { u->b, v->a } { u->b, v->b } { u->b, v->c } { u->c, v->a } { u->c, v->b } { u->c, v->c } #(S -> T) = 32 = 9

24. Mappings (ต่อ) • TYPE color = (red, green, blue) pixel = array[color] of 0..1; • การ map ค่าของเซต color ไปบนเซตของ { 0,1 } จะได้pixel = color -> { 0,1 }= { red -> 0, green -> 0, blue -> 0 } { red -> 1, green -> 0, blue -> 0 } { red -> 0, green -> 0, blue -> 1 } { red -> 1, green -> 0, blue -> 1 } { red -> 0, green -> 1, blue -> 0 } { red -> 1, green -> 1, blue -> 0 } { red -> 0, green -> 1, blue -> 1 } { red -> 1, green -> 1, blue -> 1 }

25. Powersets • ชนิดข้อมูลที่ต้องการรวบรวมข้อมูลที่มีชนิดเดียวกันเข้าด้วยกันเช่นเดียวกับชนิดข้อมูลแบบอาเรย์ แต่การทำงานกับเซตไม่ต้องการดึงข้อมูลทีละตัวในเซต แต่ต้องการทำงานกับเซตทั้งชุด • การดำเนินการกับเซตเหมือนกับการดำเนินการของทฤษฎีเซต คือunion, intersection, different • สัญลักษณ์ S หมายถึง เซตของสับเซตทั้งหมดของเซต S S = { s / s S } # S = 2#S

26. Powersets (ต่อ) • TYPE color = (red, green, blue) Hue = set of color • ค่าที่เป็นไปได้ทั้งหมดของเซต hue คือเซตของสับเซตทั้งหมดของ color หรือ powerset ของเซต color color ={ { }, {red}, {green}, {blue}, {red, green}, {red,blue}, {green,blue}, {red, green, blue} }

27. Type checking • การตรวจสอบชนิดข้อมูล ก่อนที่จะมีการดำเนินการ (operation) ใด เพื่อป้องกันไม่ให้โปรแกรมทำงานที่เป็นไปไม่ได้กับชนิดข้อมูลหนึ่ง ๆเช่น นำข้อมูลอักขระมาทำ operation คูณ กับข้อมูลบูลีน • ประเภทของ Type checking แบ่งตามช่วงเวลาที่ตรวจสอบ • Static type checking ตรวจสอบชนิดข้อมูลในช่วงเวลาการแปลโปรแกรม (compile time) โดยตรวจสอบว่าชนิดของตัวแปรที่กำหนดไว้ถูกต้องหรือไม่ • Dynamic type checking ตรวจสอบชนิดข้อมูลในช่วงเวลาการทำงานของโปรแกรม (run time) ตัวแปลภาษาจะไม่สามารถตรวจสอบได้ว่ากำหนดชนิดข้อมูลของตัวแปรถูกต้องหรือไม่ จนกว่าจะ execute

28. Type checking (ต่อ) Pascal Function Even ( n : integer ) : boolean; begin Even := (n mod 2) = 0 end; Lisp Function Even ( n ); begin Even := n mod 2 = 0 end;

29. Type equivalence • เทคนิคที่ใช้ในการตรวจสอบว่าตัวแปร 2 ตัวหรือมากกว่า เป็นตัวแปรชนิดเดียวกันหรือไม่ • วิธีการตรวจสอบมี 2 ลักษณะ คือ • Name Equivalence ตัวแปร X และ Y จะเป็นตัวแปรที่มี Name equivalence กันก็ต่อเมื่อตัวแปรทั้งสองมีชื่อชนิดของตัวแปร (Type name) เหมือนกัน • Structure Equivalence ตัวแปร X และ Y จะเป็นตัวแปรที่มี Structure equivalence กันก็ต่อเมื่อตัวแปรทั้งสองมีโครงสร้างเหมือนกัน

30. Type equivalence (ต่อ) a name equivalence b.d TYPE arr_type = array[1..20] of integer; VAR x, y : array[1..20] of integer; a : arr_type; b : RECORD c : integer; d : arr_type; END; a structure equivalence b CONST N = 2; VAR a : array[1..N] of char; b : array[1..N] of char;