2. Blowing your mind with a simple truth

Transcription

1 1. Languages are classified by their memory management scheme In garbage collected languages such as Java, python, C#, etc., the system handles the task of freeing memory + Much faster to write programs + Much, much, much less error-prone Tends to keep memory around longer than necessary Runs much, much much slower and less predictably In manually memory managed languages such as C, Fortran, C++, etc., the user directly controls memory allocation and deallocation + Memory usage can be minimized by freeing data as early as pos + No sys process need run to do garbage collection, resulting in better and more predictable performance Takes longer to produce a working program, since programmer must manually control memory Working program often still contains mem management bugs: 1. deallocation of never allocated memory 2. memory leak: failure to deallocate memory after use 3. double free of allocated memory 4. Access past end of allocated memory You must understand how memory is organized and how variables are stored in it 2. Blowing your mind with a simple truth Everything that a computer can do comes down to manipulating binary numbers (boolean math) Every single thing involved in programming is stored in a computer as a binary number: 1. The instruction of your compiled program are stored in memory as binary numbers (text/code section of memory) 2. All automatic variables are dynamically allocated and deallocated to the stack as needed (as binary numbers, even strings!) 3. All global and static variables are stored in the data portion (as binary numbers) 3. Fundamental data types in C The two fundamental data types are the integral and floating point types: 1. Integral types: store integer numbers Default type: int Constants: 10, 0, 0xFFFA, 32 Size variants: char, short, int, long int Modifiers: unsigned, signed 2. Floating point types: store real numbers Default type: double Constants: 0.5, 10.0, 0.0, 1.2e3 ( == ) Size variants: float, double, long double Modifiers: none 4. Numbers are infinite, but storage is finite long int l; short s; char c; printf("\nsizeof(char,short,int,long int) = (%lu,%lu,%lu,%lu)\n\n", sizeof(c), sizeof(s), sizeof(i), sizeof(l)); printf("char short int long int\n"); printf("==== ====== =========== =====================\n"); c = s = i = l = 1; do c *= 2; s *= 2; i *= 2; l *= 2; printf("%4d %6d %11d %21ld\n", c, s, i, l); while (l > 0);

2 5. Numbers are infinite, but storage finite: OUTPUT sizeof(char,short,int,long int) = (1,2,4,8) char short int long int ==== ====== =========== ===================== There are infinite numbers between any two real numbers Not all numbers can be stored: * Real #s continuous and infinite * fp #s discreet and finite 1. Can be too large overflow 2. Can be too small underflow or subnormal/denormalized 3. Can have too many significant digits rounded 4. Can have no representation in fp storage rounded Infinite decimal in binary storage, eg double d; float f; f = 0.1; d = 0.1; printf("0.1 = %.20f\n", f); printf("0.1 = %.20lf\n", d); >gcc -o xtst real.c 0.1 = = Waitaminute: did you say char was an int? Everything is stored as number. It s all down to interpretation, and 1-byte (8 bits, unsigned int) chars can be translated as integers or characters, with translation from ASCII character codes (left). char ca = 65; printf("ca = %c (%d) %c!\n", ca, ca, ca+32); for (i=65; i < 91; i++) printf("%c", i); printf("\n"); ca = A (65) a! ABCDEFGHIJKLMNOPQRSTUVWXYZ DEC CHAR 0-8 nonprinting 9 \t : tab 10 \n : line feed nonprinting 32 space 33! 34 " 35 # 36 $ 37 % 38 & ( 41 ) 42 * , / DEC CHAR : 59 ; 60 < 61 = 62 > 63? A Z 91 [ 92 \ 93 ] 94 ^ 95 _ a z ~ 127 DEL 8. Classifying variables C has three general classifications of variables, which control when they are created and destroyed: 1. automatic variables (AKA local or dynamic variables): declared: inside scope () without static mod example: main(void) int i, k; accessible: only within scope lifetime: Come into existence when scope is entered during execution, deallocated when scope execution finished. Parameters are local to scope of func 2. Global variables: declared: outside functions example: int GLOB_I, JJJ=10; (appearing outside any scope) accessible: any code (using extern outside file) lifetime: Exist for entire life of program. GLOB_I has undefined start value, but JJJ is 10 at start of execution. 3. private global variables: declared: outside or inside scopes with static modifier example: static int II=0, JJ=10; accessible: by same file or private to scope (see below) lifetime: Exist for entire life of program. If decl appears inside scope, the variable is private to the scope; if decl outside scope, the variables are private to the file.

3 9. A Program s Memory Address Space Each prog (process) has full address space, as on right: Exact organization varies by architecture: Typically, heap begins at and grows upward Stack begins at and grows downward Memory between heap & stack is unused, and will not be allocated in mem or on disk until created instructions of program are stored in the text sec global variables exist for entire execution, and are allocated in the data section of heap; are initialized at program startup, and dealloced at program end Dynamically allocated memory is explicitly allocated (in the heap) (malloc/calloc) and dealloced (free) by the programmer Automatic variables exist only within a scope, and are automatically allocated and dealloc by compiler on the stack upon scope invocation and completion 0xFFFFFFFFFFFFFFFF stack unused space heap data (global) text (code) 0x0 void PrintYourStack(int i); printf("addr(i)=%lu\n\n", PrintYourStack(i); #define UL (unsigned long) void PrintYourStack(int i) int j, k; char c; printf("addr(i)=%lu\n", printf("addr(j)=%lu\n",ul &j); printf("addr(k)=%lu\n",ul&k); printf("addr(c)=%lu\n",ul&c); if (1) printf("addr(i)=%lu (IF!)\n", UL&i); 10. Stack example automatic vars can share name, but not be same var Compiler free to reorder vars within funcs but conceptually, stack would look like: main i PYS i PYS j PYS k PYS c IF i void PrintYourStack(int i); printf("addr(i)=%lu\n\n", PrintYourStack(i); #define UL (unsigned long) void PrintYourStack(int i) int j, k; char c; printf("addr(i)=%lu\n", printf("addr(j)=%lu\n",ul &j); printf("addr(k)=%lu\n",ul&k); printf("addr(c)=%lu\n",ul&c); if (1) printf("addr(i)=%lu (IF!)\n", UL&i); 11. Stack example (continued) >gcc -Wall -ansi -O3 -o xtst stackprn.c ADDR(i)= ADDR(i)= ADDR(j)= ADDR(k)= ADDR(c)= ADDR(i)= (IF!) & is the address operator main s stack frame 29 bytes from Print- YourStack s compiler puts other stuff besides auto vars on stack! Comp roughly reversed order of local vars for PYS Int paras 4 bytes apart (sizeof(int) = 4)! Comp puts char 1st, skips addr for alignment Comp has put if s i in with PYS s to avoid adjusting stack 12. Understanding variables and being confused by pointers Every variable has a lifetime (scope) Every variable has a location in memory (AKA an address) where its value is stored Two variables with the same name can have different values because they are stored in different locations! Every time you reference a variable in your program, the computer is looking up it s value from the address! (small lie) If two variables map to same location they are usually automatic variables that do not exist at the same time Two variables that map to same location at the same time are usually a union, which we don t know yet Remember: everything stored as binary #: variable declaration tells compiler how to interpret value! A pointer is a new kind of variable, that instead of storing a normal value, stores an address in memory. A pointer is often initialized with the address operator (&) The value a pointer points to can be changed by using the dereference operator (*)

4 #define UL (unsigned long) int i=2, j=4, k; int *ip; k = 2; k = 3; printf("i,j,k=(%d,%d,%d)\n", i, j, k); ip = &j; printf("addr(j)=%lu, ip=%lu\n", UL &j, UL ip); printf("j=%d, *ip=%d\n", j, *ip); i = 28; printf("j=%d, *ip=%d\n", j, *ip); *ip = 35; printf("j=%d, *ip=%d\n", j, *ip); printf("addr(j)=%lu, ip=%lu\n", UL &j, UL ip); ip = &k; *ip = 102; printf("i,j,k=(%d,%d,%d)\n", i, j, k); int i=0, j=1; int ChangeIt(int i, int j); i = ChangeIt(i, j); int ChangeIt(int i, int j) i += 8; j += 9; return(i); >gcc -ansi -o xtst ptr1.c i=0, j=1 i=8, j=1 13. Understanding pointers >gcc -ansi -o xtst ptr0.c i,j,k=(2,4,3) ADDR(j)= , ip= j=4, *ip=4 j=4, *ip=4 j=35, *ip=35 ADDR(j)= , ip= i,j,k=(28,35,102) A ptr points to/refers to the storage location of another variable! When we take an action on the data referred to by the ptr, we say we dereference it Applied to a ptr, * is the dereference operator * also indicates ptr declaration As long as ip pts to j s storage, changing one changes the other! not true once it pts somewhere else! 15. Why pointers? int i=0, j=1; void ChangeIt(int*, int*); ChangeIt(&i, &j); void ChangeIt(int *ip, int *kp) *ip += 8; *kp += 9; >gcc -ansi -o xtst ptr2.c i=0, j=1 i=8, j= Understanding pointers II Just like other variables, ptrs get space in memory, but what is stored there is a memory address, rather than the usual integer value Ptrs are really just integers that are long enough to store a complete memory address When a ptr is dereferenced for a read (eg., j = *ip;): 1. The compiler loads the address stored in the ptr s storage loc 2. The compiler then loads the value from the address just loaded from the ptr s storage Compiler knows how to interpret the value because the declaration of ip tells it what type it points to (eg., int *ip;). Pointers usually slower to use than variables! 16. Understanding 1-D arrays An array is a way to associate multiple items with a single name: individual items are accessed by indexing (AKA subscripting/offsetting), in C this is array[index] Arrays can be accessed in loops more conveniantly using loop counter as index. Eg., search an N-length array for the value -1: for (i=0; i < N; i++) if (iarr[i] == -1) return(i); int iarr[4];... iarr[3] iarr[2] iarr[1] iarr[0] main... #define UL (unsigned long int) int i, iarr[4] = 0, 1, 2, 3; printf("%lu, %lu\n", UL iarr, UL &iarr[0]); printf("%lu, %lu\n", UL (iarr+1), UL (&iarr[1])); for (i=1; i < 4; i++) printf("dist iarr[%d] = %d\n", i, (int)((ul(&iarr[i]))-(ul iarr))); >gcc -ansi -o xtst arr0.c , , dist iarr[1] = 4 dist iarr[2] = 8 dist iarr[3] = 12

5 17. Arrays and Pointers Pointers can be offset/indexed just like arrays Pointers can point to arrays Arrays are simply pointers that have space allocated by the compiler and can t change what they point to! iarr[3] iarr[2] ip iarr[1] iarr[0] main... Q1 What would ip[-1] = 22; do? Q2 How about ip[3] = 7;? int i, iarr[4] = 0, 1, 2, 3, *ip; ip = &iarr[1]; printf("ip[1]=%d, iarr[2]=%d\n", ip[1], iarr[2]); printf("iarr[3]=%d\n", iarr[3]); ip[2] = 55; printf("iarr[3]=%d\n", iarr[3]); ip[1]=2, iarr[2]=2 iarr[3]=3 iarr[3]= Memory overwrites and the pointer foot-gun Pointers can point at any piece of memory and then you can choose to do crazy stupid things with very hard-to-predict side effects: #define UL (unsigned long int) main(void) volatile int i=0, j=1, k=2, *ip; printf("ia=%lu\nja=%lu\nka=%lu\n", UL&i, UL&j, UL&k); ip = &j; ip[1] = 55; printf("i=%d, j=%d, k=%d\n", i, j, k); printf("*ip=%d, ip[0]=%d\n", *ip, ip[0]); >gcc -ansi -o xtst ptr3.c ia= ja= ka= i=0, j=1, k=55 *ip=1, ip[0]=1 k ip j i main Pointers, dynamic memory allocation, and variable length arrays Pointers and memory allocation can be used to handle arrays of unknown or varying lengths (dynamically sized arrays): #include <stdlib.h> #include <assert.h> int i, N; int *ip; printf("enter length of array: "); assert(scanf("%d", &N) == 1); ip = malloc(n*sizeof(int)); assert(ip!= NULL); for (i=0; i < N; i++) ip[i] = i; for (i=0; i < N; i++) printf("ip[%d] = %d\n", i, ip[i]); free(ip); Enter length of array: 2 ip[0] = 100 ip[1] = 101 malloc (memory allocate): tries to allocate space on the heap as specified by length argument malloc should return NULL (0) if no memory available We use assert to ensure we got memory before using it! free: releases previously allocated memory back to system On a different run, the array length could be 10,000 w/o error! Run program with valgrind --leak-check=yes anytime dynamic memory is used! 20. Strings are null-terminated 1-D arrays of chars In C, strings are simply 1-D arrays of chars: Maximum length of string declared as usual: char str[256]; End of printing string indicated by \0 (int/ascii 0) Strings called null (0) terminated (NULL of ptrs also 0) /* printf */ #include <stdlib.h> /* malloc */ #include <string.h> /* strcpy/strlen */ #include <assert.h> /* assert */ int main(int nargs, char *args[]) char *s1 = "default str"; char s2[8]= h, e, l, l, o, \0,0,0; char *s3; char *dynstr; printf("s1 = %s \n", s1); printf("s2 = %s \n", s2); s3 = (nargs>1)? args[1]:args[0]; i = strlen(s3); assert(i > 0); dynstr = malloc((i+1)*sizeof(char)); assert(dynstr); strcpy(dynstr, s3); printf("dynstr(len=%d) = %s \n",i,dynstr); free(dynstr); bob s1 = default str s2 = hello dynstr(len=3) = bob./xtst s1 = default str s2 = hello dynstr(len=6) =./xtst size_t strlen(const char *s);: Returns length of string not including null terminator! char *strcpy(char *dest, const char *src);: copies src to dest assuming src is long enough!

6 21. Pointers can be used to return whole arrays /* printf */ #include <stdlib.h> /* malloc */ #include <assert.h> /* assert */ void my_strcpy(char *out, char *in) /* not same as real strcpy */ while(*out++ = *in++); int my_strlen(char *s) int i=0; if (s) for (i=0; s[i]; i++); return(i); char *DupString(char *s) char *ns; i = my_strlen(s) + 1; ns = malloc(sizeof(char)*i); assert(ns); my_strcpy(ns, s); return(ns); int main(int nargs, char *args[]) char *s1 = "default str"; char s2[8] = h, e, l, l, o ; char *s3; char *dynstr; printf("s1 = %3.3s \n", s1); printf("s2 = %s \n", s2); s3 = (nargs>1)? args[1]:args[0]; dynstr = DupString(s3); i = my_strlen(dynstr); printf("dynstr(len=%d) = %s \n", i, dynstr); free(dynstr); >gcc -Wall -ansi -g -o xtst str1.c str1.c: In function my_strcpy: str1.c:7:4: warning: suggest parentheses around ass s1 = def s2 = hello dynstr(len=6) =./xtst