1. Computer Science 210 Computer Organization
Arrays and Pointers

2. 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

3. Declaring Array Variables
int integers[10]; // Cells for 10 ints
char letters[5]; // Cells for 5 characters
float matrix[3][2]; // A 3 by 2 matrix of floats
int max = 100; // The number of cells in the next array
double doubles[max]; // 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!

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

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

6. 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("%d\n", array[i]);
The number of data values is tracked with a separate variable
This length variable is also used in processing the array later

7. 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 = getNumbers(numbers, max);
if (length > 0)
printf("The average is %f\n",
sum(numbers, length) / (double) length);
else
printf("No numbers were entered\n"); }
An array can be passed as an argument to a function
The function can access or replace values in the array cells

8. Example: Find the Minimum
// Returns the index of the minimum value in the array
int minIndex(int array[], int length){
int probe, minPos = 0;
for (probe = 1; probe < length; probe++)
if (array[probe] < array[minPos])
minPos = probe;
return minPos; }
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

9. 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

10. 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)

11. The Address of Operator &
int number = 10;
printf("The value is %d\n", number); // The contents of number
printf("The address is %p\n", &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

12. 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
alias
The memory for alias contains garbage until it is set to a value 10

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

14. Access by Indirection (Dereferencing)
int number = 10;
int *alias = NULL; // Set the pointer variable to empty
int aCopy = number; // Copies number’s value to aCopy
alias = &number; // Copies number’s address to alias
printf("The value is %d\n", number);
printf("The value is %d\n", *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

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

16. 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

17. Use & with the Actual Parameter
#include <stdio.h>
#include <math.h>
int main(){
float a, b, c, root1, root2;
printf("Enter a, b, and c: ");
scanf("%f%f%f", &a, &b, &c);
quadraticRoots(a, b, c, &root1, &root2);
printf("Root1: %f\nRoot2: %f\n", root1, root2); }
The function quadraticRoots 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

18. Use * with the Formal Parameter
#include <stdio.h>
#include <math.h>
void quadraticRoots(float a, float b, float c,
float *root1, float *root2);
int main(){
float a, b, c, root1, root2;
printf("Enter a, b, and c: ");
scanf("%f%f%f", &a, &b, &c);
quadraticRoots(a, b, c, &root1, &root2);
printf("Root1: %f\nRoot2: %f\n", root1, root2); }
Input parameters
Output parameters
In the function header, the root1 and root2 parameters are of type pointer (*) to float
This allows them to receive the addresses of float variables when the function is called

19. Use * to Access or Modify Data
#include <stdio.h>
#include <math.h>
void quadraticRoots(float a, float b, float c,
float *root1, float *root2);
int main(){
float a, b, c, root1, root2;
printf("Enter a, b, and c: ");
scanf("%f%f%f", &a, &b, &c);
quadraticRoots(a, b, c, &root1, &root2);
printf("Root1: %f\nRoot2: %f\n", root1, root2); }
float *root1, float *root2){
(*root1) = - b + sqrt(b * b - 4 * a * c) / (2 * a);
(*root2) = - b - sqrt(b * b - 4 * a * c) / (2 * a);
Input parameters
Output parameters
Use dereference (*) to store an integer in the implementation

20. 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

21. 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
printf("%d\n", array[i]); }

22. 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 *arrayPtr, *lastAddress = array + max - 1;
for (arrayPtr = array; arrayPtr <= lastAddress; arrayPtr++)
printf("%d\n", *arrayPtr);
arrayPtr is an alias for array (the address of the first cell)
lastAddress is the address of the last cell in the array structure
arrayPtr is incremented to move through the array structure, and * is used to access each cell

23. For Friday
Strings in C