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
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!

 Initializing and Processing
int max = 10, array[max]; // Declare variables

for (int i = 0; i < max; i++) // Store 1..max in the array

array[i] = i + 1;

for (int 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

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

 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

 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

 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
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 %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

 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
10 contains garbage until it is set
to a value
 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
10 10 contains the address of
number
 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
 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
 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, 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

 Use * with the Formal Parameter
#include <stdio.h> Input parameters
#include <math.h>

void quadraticRoots(float a, float b, float c,

float *root1, float *root2);

int main(){ Output parameters

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);
}

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
 Use * to Access or Modify Data
#include <stdio.h> Input parameters
#include <math.h>

void quadraticRoots(float a, float b, float c,

float *root1, float *root2);

int main(){ Output parameters

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);
}

void quadraticRoots(float a, float b, float c,

float *root1, float *root2){
(*root1) = - b + sqrt(b * b - 4 * a * c) / (2 * a);
(*root2) = - 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("%d\n", 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 *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
For Friday

Strings in C