CS-240 Data Structures in C Arrays

1. CS-240 Data Structures in CArrays Dick Steflik

2. Abstract Data Type • A collection of pairs <index,value> 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 storageretrieve(A,i) – return v at position i in A store(A,I,v) – store v at position i in Adestroy(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 0initialization 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 4th 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) = 100016 + (316*416) = 100c16base 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 1 0 1 0 0 0 1 1 1

18. cont. int a[2][2] 0 1 2 3 0x100000 0x100004 0x100008 0x10000C 0,0 0,1 1,0 1,1 This storage arrangement is known as: Row Major Order a[m][n]) SMF = base addr + (dim(n) * element size * indexm ) + (element size * indexn ) 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 one dimensional array where: index represents the exponent and the stored value is the corresponding coefficient // an array of struct #define MAXTERMS 10 typedef struct term { real coeff; int expnt;} term poly1[MAXSIZE]; term poly2[MAXSIZE]; term poly3[MAXSIZE]; OR 2x8 + 4x2 + 1 0 1 2 3 4 5 6 7 8 9 2 1 4

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