NCCU 資訊碩專班 Advanced Programming Languages

Transcription

1 NCCU 資訊碩專班 Advanced Programming Languages 高等程式語言 Instructor: 資科系陳恭副教授 Spring 2006 Lecture 5: Variables, Assignment, Block, Store

2 More Semantic Concepts Variable Model Binding Concept Blocks and Scopes Memory Models Allocation/Deallocation Lifetime Garbage Dangling pointers

3 Variable Models Why? Analyze reality and find solutions

4 Models and Modeling A model is a simplification (abstraction) of reality. For analysis problems and finding solutions For prediction (theory) Modeling is the process that construct models. Models F = m * a Formal and informal models

5 Modeling Variables: A First Try A variable has a name and a value. So A intuitive and simplified model of variables: State (or Store) maps variable names to values directly State: Name Value Ex: if Sto(x) = 10; then x+5 will evaluate to 15 This is not capable of modeling variables in C/C++, Java, 觀察 : if Sto(x) = 10; how to interpret x = x + 5;? We need to refine the model! Let us first collect more examples for modeling.

6 Variables: Names, Locations & Values A variable is an abstraction of a memory cell The essential attributes of a variable name, location and value (some more later) Name: usually identifiers such as car, temp, sqrt, denote (refer to) a location Anonymous variables? Location: logical address, not real (physical) addresses Value: what can be stored in a location Typed values Primitive types: int, float, double, char, boolean, Composite types: structure in C (record in Pascal, COBOL), union in C, another location (pointer, reference), Principle operation on variables: Assignment x = 1; x = x + 1;

7 Motivating Examples There are two declarations of x. When we use x in bar(), which declaration are we using? Name resolution and name scope Scope rule Example: int x; void foo (int y) { float x; x = 100; bar(); } Void bar() { print(x); // which declaration of x? } int main() { x = 1; foo();... }

8 Motivating Examples What s wrong with the function dp? What does kp points to after the execution of do? What s wrong with the function garbage? Does it consume too many unneeded memory spaces? Memory allocation Examples: int *dp(int i) { int k, *kp; k = i; kp = &k; return kp; } int garbage(int c) { toy_t *tp; int total= 0; tp = (toy_t *) malloc(c*sizeof(toy_t)); tp->price = discount(price);... total = tp_price * c; return total; }

9 Basic Semantic Concepts Variables in Imperative Languages Variable & Assignment Binding and Binding Time Values and Types Type Binding Scope Memory lifetime

10 Variables and Assignment We use the name of a variable to refer to (denote) both its location and its stored value. Location vs. Value x = x + 1; The same x denotes two different meanings! L-values vs. R-values The right x is implicitly dereferenced to obtain the value stored therein. Some languages require explicit dereferencing (!): X = ref 0; x =!x + 1; (SML)

11 L-values and R-values memory: a very large array 9 0x7B1 0x7B1: 9 For a variable, by L-values: we mean locations (label on the box) R-values: we mean stored values (contents of the box)

12 A New Model of Variables We need a two-level mapping from variable names to their values. Two mappings: Environment and Store (state) Environment Store Names Locations Values x = x + 1; The left x is mapped to a memory location (address) by Env; The right x is mapped to a memory location by Env and then the value stored therein by the Sto.

13 The New Model Can model variables of different kinds: Pointers Variables whose values are other variables locations int i = 0, *ip = &i; Sto(Env(ip)) == Env(i) Call-By-Reference int f(int & x) { x = x+1; return x; } The argument s location, instead of value, is passed. Aliases int y = 5; i = f(y); During the execution of f, x is an alias of y. Any changes to x will affect y s value.

14 The Environment Environment: Names (Id) Locations How is the environment constructed? Viadeclarations! int x, y; We say the above declaration binds x and y to two different locations, which info is kept in the environment. How about procedure/function declarations? int double(int n) { return n+n; } Similar to variable declarations. But then we need to modify the def of Env.

15 Environment and Binding The Environment keeps the bindings of names declared by the programmer and those of predefined names, too. double is a user-defined function printf is a predefined procedure Binding: associate names with their values We need to modifies the ranges of an environment Env: Names Locations X Environment: Names (Denotable) Values for now denotable values = { primitive values} {function values} {Locations} Literals such as 1, 1,5

16 General Binding Concepts

17 Names & Identifiers A name is a mnemonic character string (identifier) representing (denoting, referencing) something else. Or to use names for particular entites, we introduce identifiers. Language identifiers: Keywords vs. Reserve words if, else, case,... User defined identifiers: Variables names Symbolic constants Function/Procedure names Data type names...

18 Binding In PLs many constructs can be given names. A fundamental semantics step: deduction of the meaning of a (user-defined) name: What does the name denote? What are its attributes?... x... y... max(x, y)... An (named) entity has associated with it a set of attributes Binding is the process of associating an attribute (value, meaning) to a name (symbol). attributes of named entitys variable: memory location, type, value name, scope, life time Named entity Binding Attributes (Values)

19 Binding Constructs Pre-defined bindings Reserved words: if, else, case, Operators:!, +, -, =, Declarations are the major binding constructs for programmers to introduce new bindings Variable declarations int x ; #define in C #define PI Function declarations int max(int x, nt y) { } x --> location, type PI --> a float value max --> a function Type declarations typedef date int; date a type alias of int

20 Binding Time Binding time is the time at which a binding takes place. Possible binding times: Language design time--e.g., bind operator symbols to operations! means logical negation in C Language implementation time--e.g., bind floating point type to a representation Compile time--e.g., bind a variable to a type in C or Java Link time extern variables in C Load time--e.g., bind a FORTRAN 77 variable to a memory cell (or a C static variable) Runtime--e.g., bind a nonstatic local variable to a memory cell Early vs. Late Binding

21 Binding Time Examples Operators: Syntax of + at language definition time Semantics of + at language definition time (Pascal) Semantics of + also at compile time (Ada, C++) + is overloaded -- which operator? -- at compile time Overloading ( 多載 ) 一個名字 / 運算子有多個意義, 視使用時的前後文決定其意義 3+5 vs vs. a + bcd Come back later. Late binding implies slower execution

22 Variable: Location, Value, Type 一變數的 location 內存的 value 可隨時透過 assignment 改變, 但其 location 的大小? 是否不宜改變? 一變數的 location 內存的 value 的種類是否固定? x = 1; x = 1.5; x = a string ; Type: values 的種類 ( a type is a set of values) int = {, -3, -2, -1, 0, 1, 2, 3, } float = {, -1.1,, 0.0,, 1.1, } Type binding: 變數宣告建立變數 name 與其 location 的對應外, 也可限定該 location 可存的 value 的種類 (type), 或者是說限定了該變數的 type. int x;

23 Type Binding 1/2 Is type an essential binding for a variable? Yes for static languages such as C/C++, and Java No for dynamic languages such as Lisp (Scheme), Prolog, and Scripting languages such as PHP, Perl (Storable) Values are typed; but Variables may not. In static languages, variables are typed: By an explicit declaration: int i; char *cp; By an implicit declaration: naming convention integer vars in Fortran: variable names beginning with letters i..n, e.g., I, N, Key string vars in Basic: variable names ending with $, e.g., astr$ Type inference (next slide) In dynamic languages, variables do not have fixed types, but depending on their values. For example, in Scheme (define var) ;; declar a variable named var without type binding (set! var 100) (set! var (a list now))

24 Type Binding 2/2 In summary, two kinds of type binding : Compile-time: static type bindingc/c++, Java, Run-time: dynamic type binding Lisp (Scheme), Prolog, APL, PHP, Perl, Usually, static type binding provides more efficient storage management because the types determine the size of locations. char c; // one or two bytes, fixed c = this cannot happen! ; C = D; // illegal, either The size of a location is fixed simple and efficient Static type binding Simple: type declarations Complex: type inference Type inference: Infer the type of a variable or an expression from context information; no need to declare types for every identifiers.

25 Type Inference Infer types without explicit type declarations Big topic in recent programming language research How many type declarations can you omit? Tied to polymorphism head: List(T) -> T l : List(float) head(l): float

26 Type Inference example function factorial ( x :? ) :?; begin if x = 0 then factorial := 1; else factorial := x * factorial(x - 1); end; We can infer that factorial returns an integer value because it returns a 1, and we can infer that x is An integer because we compare it to an integer. We could then check all the calls to factorial to determine if they passed an integer. head: List(T) -> T l : List(float) head(l): float

27 Summary of Type Binding When does the binding take place Explicit declaration (static type binding) Implicit declaration (static type binding) Type Inference (static) Determined by context and value (dynamic) Dynamic Type Binding When a variable gets a value, the type of the variable is determined right there and then.

28 Static vs. Dynamic Binding A binding is static if it first occurs before run time and remains unchanged throughout program execution. #define in C/C++ A binding is dynamic if it first occurs during execution or can change during execution of the program. Values of variables Location bindings (later) Type binding in Scheme (later)

29 Scopes

30 Motivating Scopes Given multiple bindings of a single name (identifier), how do we know which binding does an occurrence of this name refer to? Two bindings for x One of type int Another float An occurrence of x int x; void foo (int y) { float x; x } int main() { foo(x); // which binding of x?... }

31 Scope Scope of a Binding (declaration) the region of the program over which the binding is maintained Scope of a Name (abuse of the term scope ) the same name may declared multiply these different declarations of the same name should be differentiated Example: Local scope vs. Global scope int X; has a global scope float X; has a local scope. int X = 0; void foo (int X) { float X; X = // which X? } int main() { int y; foo(x); // which X?... }

32 Block and Scope Block a standard language construct which may contain declarations unit of scope and memory allocations Declaration before Use Rule: The scope is typically extends to the end of the block which contains the declaration Kinds of Blocks procedural block: Pascal non-procedural block: Ada, C ({ }) -- Ada example declare x: integer; begin end (* Pascal example *) program ex; var x: integer begin end

33 An Example of Block Scope in C int x; void p(void) { int i; } void q(void) { int j; } main() { int k; } i j k main q p x

34 Scope Holes What is a scope hole? a local declaration of a name can mask a prior declaration of the same name in this case, the masked declaration has a scope hole over the corresponding block Visibility and Scope Visibility: the region where the declared name is visible (excluding scope holes) Scope: the region where the binding exists (including scope holes)

35 Scope and Visibility: An Example in C int i=0; void p(void) { int i=2; } void q(void) { int j; } main() { int i; } i j i i scope hole i i scope hole scope visibility

36 Nested Blocks Block-Structured Program The program is consisted of blocks, which may be nested Most Algol descendants exploit this structure Nested blocks: Variables can be hidden from a unit by having a "closer" variable with the same name (scope hole) C and C++: for (...) { int index; { int k, index;... } } Lisp: (let ((a 1) ) (b foo)) (let ((c ) (+ a b))) (if (eq? b 0) c (else (* a b)))

37 Example: Identifier Scopes in ANSI C Block scope (local): float f ; { int a;... }... {int b;... } scope of variable a scope of variable b File Scope: Declared outside any blocks or functions, or function prototype ( f above) current file global

38 File Scope in C File Scope In C, a global name can be turned into a file scope name by attaching the keyword static. A file scope name can only be referenced in that file. Example File 1 extern int x;... x... File 2 int x;... x... File 3 static int x;... x...

39 ANSI C Scopes (Cont d) Function prototype: Scope of formal parameters: int foo(int n); scope of parameter n Function Scope: only for labels: void foo() {... goto lab;... lab: i++;... goto lab;... } scope of label lab, Note in ANSI-C all labels have function scope regardless of where they are

40 Scope Resolution Operator (::) of C++ // C++ example int x; void p(void) { char x; x = 'a'; // local x ::x = 42; // global x... } /* p */ main() { x = 2; // global x... } The global integer variable x has a scope hole in the body of p. In C, the global x cannot be referenced in p. In C++, the global x can be referenced in p using a scope resolution operator ::. Ada also has a scope resolution operator..

41 Scopes and Scope Rules The non-local variables of a program unit are those that are visible but not declared there We need some rules to locate corresponding declarations for nonlocal references. (name resolution) Local first; i.e., searching from the current environment Where then to find the binding for reference to non-local variables Non-local variable int X; void foo (int z) { X // which X? } int main() { int X; foo();... }

42 Scope Rules (for Non-locals) Static (Lexical) scope most languages Based on program text Search enclosing scope until the proper binding found Dynamic scope (older versions of Lisp) Based on program execution Trace the function calling-chain to find the proper binding Non-local variable int X; // this X, if static scope void foo (int z) { X // which X? } int main() { int X; // this X, if dynamic scope foo();... }

43 Static vs. dynamic scoping program MAIN; var a : integer; procedure P1; begin static (lexical) non-local variables are bound based on program structure MAIN print a; end; {of P1} if not local, go out a level example prints 7 P1 P2 procedure P2; var a : integer; begin a := 0; P1; end; {of P2} dynamic non-local variables are bound based on calling sequence MAIN P2 begin a := 7; if not local, go to calling point P1 P2; end. {of MAIN} example prints 0

44 Example: Static vs. Dynamic Scope int x = 1; char y = a ; void p(void) { double x = 2.5; printf( %c\n, y ); { int y[10]; } } void q(void) { int y = 42; printf( %d\n, x ); p(); } main() { char x = b ; q(); return 0; } Non-local Static scope: q(): print 1 p(): print a Dynamic scope: q(): print 92 ( b ) p(): print * (42) 呼叫執行順序 : MAIN calls q() q calls p() p uses nonlocal y

45 Nested scopes program MAIN; var a : integer; procedure P1(x : integer); procedure P3; begin print x, a; end; {of P3} begin P3; end; {of P1} many languages allow nested procedures static scoping example prints 1, 7 MAIN P1 P2 P3 procedure P2; var a : integer; begin a := 0; P1(a+1); end; {of P2} begin a := 7; P2; end. {of MAIN} dynamic scoping example prints 1, 0 MAIN P2 P1 P3

46 Name Bindings and Reuse Name Reuse, Multiple bindings 1. The same name is used to denote different entities in different categories. 2. The same name (identifier) can be bound to different things at different points in the program. 1. Name spaces 相同名字但不同 names pace, 不牴觸 package Reuse; // 極端案例 class Reuse { Reuse Reuse(Reuse Reuse) { Reuse: for (;;) { if (Reuse.Reuse(Reuse) == Reuse) break Reuse; } return Reuse; } } 2. 各有地盤 int X; void foo (int y) { float x; x } int main() { foo(x);... }

47 Name Spaces A general terms and also a special term in C++ ANSI C recognizes four distinct name spaces: one for tags, one for labels, one for members of a particular struct or union, and one for everything else. C++ namespaces are optionally named scopes, like packages in Java. Scopes are more complicated.

48 Memory Model & Management Storage Allocation/Deallocation Runtime Stack and Heap Lifetime Garbage and Dangling Pointers Misc.

49 Memory Model 程式執行期間記憶體的使用管理 : 程式碼部分比較單純 大型常數集中儲存 (constant pool) 但變數所需要的記憶體空間是如何決定的? Executable Image Code Constant(literal) pool 變數記憶體配置 靜態 動態 Data

50 Static Memory Model 早期程式語言 ( 如 Fortran) 的變數的配置是完全靜態的, compiler 編譯時即算出所有變數 ( 含副程式參數 ) 需要的記憶體空間及相對位置, 待程式載入執行時這些變數的位置就固定 (Load-time), 直到程式結束

51 Static memory model Cannot Support Recursion program test procedure p(x : short) var s, r: short; begin P(0); end procedure q(y : short) begin p(4); end begin q(2); p(3); end instruction memory <p> JUMP <p> JUMP <q> JUMP <p> <q> <main> data memory s (of p) r (of p) x (of p) y (of q)

52 Memory Model: Runtime Stack 靜態配置的作法雖然效率好, 但因為赴程式的參數與本地變數都只有固定的位置, 缺乏彈性且無法支援 recursion 現在的程式語言多是依不同需求, 將靜態 動態配置搭配, 兼顧效率與彈性, 所以不同種類的變數有不同的配置方式 首先, 要支援 recursion, 引進了 runtime stack 的作法 用它來儲存副程式的參數與本地變數等資訊, 並透過其先進後出的特性來支援 recursion 完整的記憶體支援需要配置位置儲存副程式的 參數與本地變數 執行結果 ( 回傳值 ) 返回位址 (return address) 其他環境資訊 ( 詳見第 6 單元 ) 所以一個副程式被呼叫執行時, 會動態配置 push 一個 activation record (stack frame) 給它儲存以上資訊 ; 副程式結束後並自動 pop 掉其 action record

53 An Activation Record (Stack Frame) Parameters Return address Dynamic link Static link Return value Local variables Runtime Stack grows as functions are called Static area Oldest frame Second Oldest frame Newest frame Details left to the Compiler course

54 Runtime Stack Memory program test procedure p(x : short) var s, r: short; begin end procedure q(y : short) begin p(4); end begin {main} q(2); p(3); SP end

55 Runtime Stack Memory program test procedure p(x : short) var s, r: short; begin end procedure q(y : short) begin p(4); end begin q(2); p(3); end SP y = 2 PC (return addr) Activation Record for q (frame)

56 Runtime Stack Memory program test procedure p(x : short) var s, r: short; begin end procedure q(y : short) begin p(4); end begin q(2); p(3); end SP s r x = 4 PC (return addr) y = 2 PC (return addr) Activation Record for p Activation Record for q

57 Runtime Stack Memory program test procedure p(x : short) var s, r: short; begin end procedure q(y : short) begin p(4); end begin q(2); p(3); end SP y = 2 PC (return addr) Activation Record for q

58 Runtime Stack Memory program test procedure p(x : short) var s, r: short; begin end procedure q(y : short) begin p(4); end begin q(2); p(3); SP end

59 Runtime Stack Memory program test procedure p(x : short) var s, r: short; begin end procedure q(y : short) begin p(4); end begin q(2); p(3); end SP s r x = 3 PC (return addr) Activation Record for p

60 Runtime Stack Memory program test procedure p(x : short) var s, r: short; begin end procedure q(y : short) begin p(4); end begin q(2); p(3); SP end

61 Limitations of Static Allocation Stack 上 activation record 的大小由 compiler 計算得出, 所以 the size of all data objects must be known at compile time No dynamic arrays Data structures cannot be created dynamically No variable length data like linked lists and trees No complicated return values

62 Memory Model: Heap Dynamic Allocation 除了 runtime stack 方式的動態配置外, 很多程式語言還支援由程式設計師自行控制的動態記憶體配置方式, 可用來製作像串列 (linked list) 等的動態資料結構 例如 :C 語言中的公用函式 malloc();c++/java 語言的 new 這些動態配置的記憶體區稱為 Heap, 是在 stack 以外的一塊記憶體空間 動態配置記憶體管理相關名詞 : Memory allocation: 從可用記憶體分配適當位置空間給變 ( 參 ) 數 Memory deallocation: 將變 ( 參 ) 數所使用的記憶體回收成可用記憶體 Memory allocation/deallocation 可由系統自動執行或由程式設計師於程式內 ( 在執行期間 ) 觸發 不同區間儲存了不同類型的變數資料

63 Categories of Variables Static variables 常數, 全域, 靜態變數 靜態配置 Stack-dynamic variables (Implicit allocation/deallocation) 參數, 本地變數, 函數返回值 由 runtime system 自動在副程式呼叫時動態配置與收回 Heap-dynamic variables 可由系統自動執行 (Implicit allocation) Example in Lisp: (set! list ( )) 系統自動配置記憶體給串列 ( ) 或由程式設計師於程式內 ( 在執行期間 ) 觸發 (Explicit allocation) Example in C Person *p ; p = (Person *) malloc( sizeof Person); p->name = Mike ; p->age = 40; free(p); Constructor ( new ) in Java and C++

64 Complete Memory Model 現代程式語言絕大多數都支援下列的 Memory model 常數, 全域, 靜態變數 參數, 本地變數, 函數返回值 動態變數 ( 透過指標存取 )

65 Summary Only Static Allocation Efficient Historic-sensitive Cannot support recursion Cannot support dynamic data structures (e.g. linked list) With Runtime Stack & Heaps More flexible Less efficient (management overhead) Support recursion (stack) Support dynamic data structures (Heap) Non-local variables access and Procedure parameters are not discussed yet

66 Lifetime (Extent) The lifetime of a storage location is the time between the location is allocated and deallocated. (The lifetime of a variable is the time during which it is bound to a particular memory cell.) The longest lifetime is the whole execution time of the program. Global and static variables Program execution time Creation of an object Object lifetime Destruction of an object

67 Blocks A common type of fixed lifetime is the time executing a block of a function/procedure. A block is a section of code in which local variables are allocated/deallocated at the start/end of the block. Introduced by ALGOL 60 and found in most PLs. Often being referred to as block-structured languages. C and C++: for (...) { int index; {... } } Ada: declare LCL : FLOAT; begin... end Nested blocks Scheme: (let* ((a 1) (b foo) (c)) (set! a (* b c)) (bar a b c))

68 Example of C Run-Time Stack A: { int x; char y; B: { double x; point 1 int a; } /* end B */ C: { char y; int b; D: { int x; double y; } /* end D */ } /* end C */ } /* end A */ Manipulation

69 Example of C Run-Time Stack A: { int x; char y; B: { double x; int a; } /* end B */ point 2 C: { char y; int b; D: { int x; double y; } /* end D */ } /* end C */ } /* end A */ Manipulation

70 Example of C Run-Time Stack A: { int x; char y; B: { double x; int a; } /* end B */ C: { char y; point 3 int b; D: { int x; double y; } /* end D */ } /* end C */ } /* end A */ Manipulation

71 Example of C Run-Time Stack A: { int x; char y; B: { double x; int a; } /* end B */ C: { char y; int b; point 4 D: { int x; double y; } /* end D */ } /* end C */ } /* end A */ Manipulation

72 Example of C Run-Time Stack A: { int x; char y; B: { double x; int a; } /* end B */ C: { char y; int b; D: { int x; double y; point 5 } /* end D */ } /* end C */ } /* end A */ Manipulation Stack-allocated variables: Lifetime 隨 block 而定, 規則式的

73 Lifetime of Heap-Allocated Variables Programmer allocated: lifetime begins when malloc() is called Constructor ( new ) is called System allocated When data structures requested (set! lst (a b c)) Deallocation when free() is called (Explicit de-allocation) Destructor is called (Explicit de-allocation) Garbage collector executed (Implicit de-allocation) 不規則

74 Garbage/Memory Leak Heap-allocated variables are sometimes called anonymous variables, and can only be accessed through pointers. Garbage: memory (heap) cell that is allocated but cannot be accessed. No pointers reference it. void f(void) { Person *p; p = (Person *) malloc(sizeof Person); p->name = Mike ; } Garbage Collection (GC): periodically sweeps the heap looking for data that cannot be accessed any more by the program and adding it back to free space. (Java, Lisp) Takes time and space!

75 Stack and Heap Review public class Strings { public static void test () { A StringBuffer sb = new StringBuffer B ("hello"); } } 1 2 static public void main (String args[]) { test (); test (); } sb Stack Heap java.lang.stringbuffer hello 1 When do the stack and heap look like this?

76 Stack and Heap Review public class Strings { public static void test () { StringBuffer sb = new StringBuffer B ("hello"); } } 2 static public void main (String args[]) { test (); test (); } sb Stack Heap java.lang.stringbuffer hello 2 1 hello

77 Garbage on the Heap public class Strings { public static void test () { StringBuffer sb = new StringBuffer ("hello"); } Stack Heap } static public void main (String args[]) { while (true) test (); } hello hello hello hello hello hello hello hello hello hello hello hello hello hello hello hello hello hello hello hello hello hello hello hello hello hello hello hello

78 Dangling Pointers Dangling pointers: pointers that point to deallocated memory locations. Mostly: deallocated heap area. Person *p; p = (Person *) malloc(sizeof Person); p->name = Mike ; q = p; free(p); q->age = 40; In C, there are dangling pointers pointed to stack area, too. int *ip, k; { int i = 10; ip = &i; } k = *ip; De-allocated

79 Summary: Dangling Pointers and Garbage Dangling Pointer A: delete (free) A B: 0.4 B: Garbage (lost heap-dynamic variables) A: 7.2 A: 7.2 B: 0.4 B: 0.4

80 Summary: GC or not to GC? Explicit memory management is more efficient But manual deallocation errors are among the most common and costly bugs too fast deallocation dangling references forgotten deallocation memory leaks Automatic GC is considered an essential feature of modern languages GC algorithms have improved implementations are more complex in general (so adding GC plays not a big role) large applications make benefits of GC greater

81 Scope vs. Lifetime Scope and lifetime are sometimes closely related, but are different concepts. A counter example in C: // int counter = 0; int number; int count () { int counter=0 counter ++; return counter; } number = count(); number = count(); // Return 1 // Still 1 Local static variables int number; int count () { static int counter = 0; counter ++; return counter; } number = count(); number = count();

82 L-Values, Pointers and References

83 L-Values & Assignment Revisited Variables: named locations Modeling variables using two mappings: Environment and Store Environment Store Names Locations Values L-value R-value Assignments in C use implicit dereferencing of L-val to get R-val on RHS of assignments. x = x + 1; Assignments in ML: make dereferencing explicit val x = ref 0; x :=!x + 1;

84 Pointers in C/C++ pointer: a variable whose value is an l-value (e.g., the location of another variable) I.e., L-values are R-values, too. declaration: int * p; p address-of operator (&): & address_of: Producing R-val p = &x; p x Pointers make things more complex.

85 Pointers in C/C++: Manipulating L- values dereference operator (*): *p = 5; p x 5 pointers can point to pointers (multi-level pointers) int x; int *p; int **r; r = &p; **r = 10; p = &x; *p = 5; r p x 5 10

86 Pointers & Dereferencing On LHS of assignments: (producing L-val) As-is: p = ( ) malloc( ); p = & x; Explicit dereferencing: *p = 5; r = &p; **r = 10; p x On RHS of assignments: (producing R-val) Explicitly dereferenced and plus an implicit dereferencing : *p = *p + 5; As-is: pointer arithmetic p = p + 2; *r = *r + 2; r When a pointer that is pointing to memory you are not allowed to access is dereferenced, the result is a program crash via a "segmentation fault"

87 Issues of C/C++ Pointers Address_of operator & Ad-hoc restrictions &i, &a[0], &struct, &s.val, Pointer arithmetic Are they pointers or integers? Pointers and arrays The confusing dereference operator * Aliasing Dangerous type cast int *ip = (int *) 0;

88 Aliases An alias occurs when the same location is bound to two different names at the same time. Direct and Indirect aliases x An alias can occurs at call-by-reference parameter passing More examples in C? Union labels are aliases Pointer aliases: indirect aliases int I; int *ip =&I; int *jp = ip; y

89 Examples of Indirect Aliases thru Pointers (References) int *x, *y; x = (int *) malloc(sizeof(int)); *x = 1; y = x; *y = 2; printf( %d\n, *x); x y 2 class ArrTest // Java { public static void main(string[] args) { int [] x = {1,2,3}; int [] y = x; x[0] = 42; System.out.println(y[0]); } }

90 C++ References: T & Pointers have too many problems; use references for specific situations to avoid the problems reference = alias name for an existing object syntax: Typename& varname;... "varname is reference to variable of Typename" float x = 42.1f; rpi, pi alias name... float& rx = x; rx, x rx = rx / ; cout << "x = " << x; const double pi = ; constdouble& rpi= pi; Implicit dereferencing rx = & y; // Error! read only reference! No need to dereference. No more magic arithmetic!

91 Reference Parameters & Aliasing Reference parameters in C++: Implicitly dereferenced void swap(int & ip, int & iq) // C++ reference parameters { int temp; temp = ip; ip = iq; iq = temp; i } j Not change to ip or iq int i = 1, j = 10; int m = 5, n = 3; swap(i, j); // i and j s locations are passed to swap ip points to i; iq points to j swap(m, n); // m and n s locations are passed to swap swap (j, j); // create aliases ip points to m; iq points to n m n

92 Aliasing Summary Alias extra name for something that already has a name (in the current scope) we may have several How are they created? Fortran: explicit declarations (equivalence) variant/union structures languages using pointers reference parameters They are considered bad because they create confusion and hard-to-track errors compilers can optimize much better if they know there s no aliasing

93 Object References in Java Java has no pointers. All Objects are referenced thru object references. Implicit dereferencing Java o1 o2 o2 = o1 o1 o2 Shallow copy vs. Deep Copy (Clone)

94 Semantics of variables Meaning of variable ( and thus assignment): I. variable has value-semantics, the variable contains the value assigned. II. Variable has reference-semantics, the variable contains as value a reference to the value assigned. From the point of view of assignment: given x = z; what does assignment copy from z to x? the location or the value of z? The value: value semantics. the location: reference semantics. Reference semantics is used in OOP. Particularly Smalltalk, Eiffel uses reference semantics, while Java uses reference semantics for objects and value semantics for primitive type values. Reference semantics give rise to aliases during assignment. Languages provide operations to actually make a copy of the value if desired.

95 General Assignments (optional) (General) Assignments: <Expression-L> := <Expression-R> evaluate <Expression-R> to get its r-value evaluate <Expression-L> to get its l-value store r-value in l-value L-values can be used as R-values, but NOT vice versa What are the legal L-value expressions in C? p+1 = 20; //??? No! *(p+1) = 20; // OK

96 Forms of L-values in C lvalue asgnop expression lvalue: identifier primary [ expression ] lvalue. identifier primary identifier * expression ( lvalue ) But in C++, we have refgen(x) = x + 100; primary: identifier constant string ( expression ) primary ( expression-listopt ) primary [ expression ] lvalue. identifier primary -> identifier int & refgen(int & w) { return w; }