1 / 21

Data Structures in C Arrays

This abstract data type collection consists of pairs <index, value>, where index is an ordered set of integers, and values are of a constant data type. Arrays in C are zero-based and contiguous from 0 to size-1, and can contain any simple or aggregate data type. This includes static and dynamic arrays, as well as the operations create, retrieve, store, and destroy.

vdixon
Download Presentation

Data Structures in C Arrays

An Image/Link below is provided (as is) to download presentation Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author. Content is provided to you AS IS for your information and personal use only. Download presentation by click this link. While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server. During download, if you can't get a presentation, the file might be deleted by the publisher.

E N D

Presentation Transcript


  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

More Related