1. CS-240 Data Structures in C Arrays Dick Steflik

2. Abstract Data Type A collection of pairs where index is an ordered set of integers and are values of some data type that is constant for the array. not all languages require index to be continuous or contiguous or start at 0 or 1. In C arrays are zero based and are contiguous from 0 to size-1 and can contain any simple or aggregate data type

3. ADT (cont.) Pascal allows discontinous indicies –A(2:5, 10:20, 26) other index values are undefined and take up no memory Perl allows indicies that are not integers but are literal values (called an associative array) –A[tom], A[dick], A[harry]

4. ADT (cont.) Static arrays – arrays allocated at compile time Dynamic arrays – arrays allocated by the storage management system at program run time

5. ADT Operations Basic operations: create(A) – allocates storage retrieve(A,i) – return v at position i in A store(A,I,v) – store v at position i in A destroy(A) – deallocate storage associated with A

6. create static storage : int a[10]; //40 bytes char word[25]; //25 bytes –allocated as part of the program space by the compiler. –&a is equivalent to a and is the address of a[0] –once allocated cannot be deallocated, will always take up program space can be initialized by compiler using an initializer (ex. int A[5] = (0,0,0,0,0); )

7. create Dynamic : storage is allocated at run-time using malloc, cmalloc or realloc #define SIZE 10 int * myarray; myarray = (int *) malloc (SIZE*sizeof(int)); makes an array of 10 integers names myarray cmalloc works same way but initializes array to 0 initialization to anything else requires a loop realloc will resize a previously allocated array to bigger or smaller since this happens at run time, time is expended

8. store done the same way for both static and dynamic arrays by using the assignment operator (=) a[5] = 9;

9. retrieve retrieving a value from some position in an array is done the same way for both static and dynamic arrays using the array position implicitly. x[3] ; //the value of the 4 th element of x can be used this way in any assignment, arithmetic/logical operation or as an argument in a function call

10. destroy destruction of a statically allocated array happened when the program is done destruction of dynamically allocated arrays is done using the free(arrayname) function, this returns the storage to the storage management system for subsequent allocation for something else. forgetting to deallocate unneeded storage is called a “memory leak” and can cause a program terminate abnormally (crash)

11. memory remember, a computer’s memory is really an array of bytes (indicies 0 to size-1) every time an array access (retrieve or store) is done the machine must make a calculation to see where in memory the desired location is: ex int a[5]; a[3]=2; to calculate the address of a[3] address=base address+(index*element size) = 1000 16 + (3 16 *4 16 ) = 100c 16 base address is assigned by compiler for static and by SMS for dynamic and kept track of in a system table for run time

12. Structures Allows us to create and aggregate data type: typedef struct person { char name[10]; int age; } person tom; - tom takes up 14 bytes of storage; 10 for name and the next 4 for age

13. Structures Structures can be embedded within one another: typedef struct date { int month; int date; int year; }; typedef struct student { char name[16]; date dateOfBirth; }; date pearlHarborDay; // 12 bytes of storage student typical; // 18 bytes of storage student class[30]; // 540 bytes of storage

14. Unions A union is like a structure but the fields don’t always have to have the same definition typedef struct sextype { enum tag (female, male) sex; union { int children; char beard; } u; }; typedef struct human { char name[10]; short age; float salary; date dob; sextype sexinfo; }; The compiler will always reserve the maximum number bytes for the union; i.e. even though sextype for wormen is 4 bytes and only one byte for men the compiler will always reserve 4.

15. Self-Referential Structures Structure that refers to an item of the same type. used for dynamic data structures like lists and trees. typedef struct node { int key; node * next; }

16. Array Mapping Functions Used by the compiler to help calculate the effective address of an array element in memory Takes into account: base address the dimension the element size

17. 2 dimensional arrays int a[2][2] can be visualized as a 2x2 square matrix but is really an array of two elements where each element is an array of two ints 0 01 1 0 1 01 01

18. cont. 0x100000 0x100004 0x100008 0x10000C 0,0 0,1 1,0 1,1 int a[2][2] This storage arrangement is known as: Row Major Order 0 1 2 3 SMF = base addr + (dim(n) * element size * index m ) + (element size * index n ) a[m][n] ) ex. a[1][1] addr = 100000 + (2 * 4 * 1) + (4 * 1) = 100000 + 8 + 4 = 0x10000C

19. Sparse Arrays arrays where many or most of the elements will have the value zero (or possibly the same value) examples: high order polynomials, bit mapped graphics, linear algebra ( diagional matricies(identity matrix, tridiagonal, banded), triangular matrices, )

20. Polynomial representation // an array of struct #define MAXTERMS 10 typedef struct term { real coeff; int expnt;} term poly1[MAXSIZE]; term poly2[MAXSIZE]; term poly3[MAXSIZE]; one dimensional array where: index represents the exponent and the stored value is the corresponding coefficient 0 1 2 3 4 5 6 7 8 9 2x 8 + 4x 2 + 1 2 41 OR

21. Identity Matrix Only has values on the major diagonal v 00 v00 00v 0 1 2 0 1 2 AMF[m][n] if (m == n) return v else return 0 map it on top of a one dimensional array of three elements v v vAMF[m][n] if ( m == n ) return A[m] else return 0