Computer Science 210 Computer Organization Arrays and Pointers

Computer Science 210 Computer Organization Arrays and Pointers

The Array Structure • A linear sequence of memory cells, each accessible by an an integer index, ranging from 0 to the number of cells minus 1 • Like Python lists and Java array lists, C arrays support random (constant-time) access to the cells

Declaring Array Variables integers[10]; char letters[5]; float matrix[3][2]; // Cells for 10 ints // Cells for 5 characters // A 3 by 2 matrix of floats int max = 100; doubles[max]; // The number of cells in the next array // Cells for max doubles The syntax <element type> <variable> [<integer expression>] declares an array variable and reserves memory for a definite number of cells (use more [] for more dimensions), each of which can store an element of the given type (arrays are statically typed) Each cell initially contains garbage!

Initializing and Processing int max = 10, array[max]; // Declare variables for (int i = 0; i < max; i++) array[i] = i + 1; // Store 1. . max in the array for (int i = 0; i < max; i++) printf("%dn", array[i]); // Print the contents Here we initialize all of the array’s cells and visit them all The loop is pretty standard

Initializing Arrays that Are Not Full int number, length = 0, max = 10, array[max]; while (1){ printf("Enter a number or 0 to stop: "); scanf("%d", &number); if (!number) break; array[length] = number; length++; if (length == max){ printf("Maximum number of numbers enteredn"); break; } } The number of data values is tracked with a separate variable This length variable is also used in processing the array later

Processing Arrays that Are Not Full int number, length = 0, max = 10, array[max]; // Get the array’s data and length here // Print all of the currently available values int i; for (i = 0; i < length; i++) printf("%dn", array[i]); The number of data values is tracked with a separate variable This length variable is also used in processing the array later

Arrays and Functions #include <stdio. h> #include "numbers. h" // Use a library of array processing functions int main(){ int max = 100; int numbers[max]; int length = get. Numbers(numbers, max); if (length > 0) printf("The average is %fn", sum(numbers, length) / (double) length); else printf("No numbers were enteredn"); } An array can be passed as an argument to a function The function can access or replace values in the array cells

Example: Find the Minimum // Returns the index of the minimum value in the array int min. Index(int array[], int length){ int probe, min. Pos = 0; for (probe = 1; probe < length; probe++) if (array[probe] < array[min. Pos]) min. Pos = probe; return min. Pos; } The element type of the array parameter must be specified, but its physical size need not be Therefore, this function can process an integer array of any physical size The logical size (length) is passed too, because the array might not be full

How Parameters Are Passed to Functions • Parameters of basic types (char, int, float, and double) are passed by value (a copy of the value of the argument is placed in temporary storage on the runtime stack) • A copy of an array’s base address is also placed in temporary storage, so its cells can still be accessed or modified

The Pointer • C allows the programmer to access the address of a memory location and use it as a data value • Pointers are also used to refer to dynamically allocated storage (from the system heap)

The Address of Operator & int number = 10; printf("The value is %dn", number); // The contents of number printf("The address is %pn", &number); // The address of number The & operator returns the actual memory address (a large integer, probably) of a variable The printf format flag p is used to print an address

Declaring a Pointer Variable int number = 10; int *alias; The * operator says that the variable alias can contain a pointer to a memory location that can hold an int number 10 alias The memory for alias contains garbage until it is set to a value

Assigning an Address int number = 10; int *alias; int a. Copy = number; // Copies number’s value to a. Copy alias = &number; // Copies number’s address to alias The variables number and a. Copy name separate storage locations The variables number and alias can access the same storage location a. Copy number 10 10 alias The memory for alias now contains the address of number

Access by Indirection (Dereferencing) int number = 10; int *alias = NULL; // Set the pointer variable to empty int a. Copy = number; // Copies number’s value to a. Copy alias = &number; // Copies number’s address to alias printf("The value is %dn", number); printf("The value is %dn", *alias); // Dereference to get value The * operator is also the dereference operator Its operand must be a pointer variable, and it must contain the address of another cell in memory The value NULL from stdio is used to indicate the empty pointer

Aliasing and Side Effects int number = 10; int *alias = NULL; // Set the pointer variable to empty int a. Copy = number; // Copies number’s value to a. Copy alias = &number; // Copies number’s address to alias (*alias) = 69; // Reset the storage by indirection printf("The value is %dn", number); // Prints 69 * Has a lower precedence than = *alias and number access the same storage a. Copy number 10 69 alias Ouch!!!

Input and Output Parameters • Parameters are passed by value, so they’re good as input-only parameters • Pointers can be used to implement pass by reference, so they’re good for output parameters (in functions that return multiple values) • Example: define a function that returns two quadratic roots, given the inputs a, b, and c

Use & with the Actual Parameter #include <stdio. h> #include <math. h> int main(){ float a, b, c, root 1, root 2; printf("Enter a, b, and c: "); scanf("%f%f%f", &a, &b, &c); quadratic. Roots(a, b, c, &root 1, &root 2); printf("Root 1: %fn. Root 2: %fn", root 1, root 2); } The function quadratic. Roots has three input parameters and two output parameters The address of a variable is passed for each output parameter The function scanf also uses this mechanism

Use * with the Formal Parameter #include <stdio. h> #include <math. h> Input parameters void quadratic. Roots(float a, float b, float c, float *root 1, float *root 2); Output parameters int main(){ float a, b, c, root 1, root 2; printf("Enter a, b, and c: "); scanf("%f%f%f", &a, &b, &c); quadratic. Roots(a, b, c, &root 1, &root 2); printf("Root 1: %fn. Root 2: %fn", root 1, root 2); } In the function header, the root 1 and root 2 parameters are of type pointer (*) to float This allows them to receive the addresses of float variables when the function is called

Use * to Access or Modify Data #include <stdio. h> #include <math. h> Input parameters void quadratic. Roots(float a, float b, float c, float *root 1, float *root 2); Output parameters int main(){ float a, b, c, root 1, root 2; printf("Enter a, b, and c: "); scanf("%f%f%f", &a, &b, &c); quadratic. Roots(a, b, c, &root 1, &root 2); printf("Root 1: %fn. Root 2: %fn", root 1, root 2); } void quadratic. Roots(float a, float b, float c, float *root 1, float *root 2){ (*root 1) = - b + sqrt(b * b - 4 * a * c) / (2 * a); (*root 2) = - b - sqrt(b * b - 4 * a * c) / (2 * a); } Use dereference (*) to store an integer in the implementation

Pointers and Arrays • An array variable is just a name for the base address of the array storage in memory • Normally, an array variable is not an l-value, meaning that it cannot be the target of an assignment statement • But, this address can be copied to another variable, which can then be modified

Process an Array Using [] #include <stdio. h> int main(){ int i, max = 5, array[max]; for (i = 0; i < max; i++) array[i] = i + 1; // Print ‘em using the array and the subscript operator for (i = 0; i < max; i++) printf("%dn", array[i]); }

Process the Array Using * #include <stdio. h> int main(){ int i, max = 5, array[max]; for (i = 0; i < max; i++) array[i] = i + 1; // Print ‘em using a pointer and dereference int *array. Ptr, *last. Address = array + max - 1; for (array. Ptr = array; array. Ptr <= last. Address; array. Ptr++) printf("%dn", *array. Ptr); array. Ptr is an alias for array (the address of the first cell) last. Address is the address of the last cell in the array structure array. Ptr is incremented to move through the array structure, and * is used to access each cell

For Friday Strings in C