Lecture #9: Arrays

Computer Programming (9) - Arrays

administrivia

Web Page - http://www.cs.tau.ac.il/~efif/courses/ComputerProgramming

last week…

we talked about how pointers can be used as function arguments (section 5.2)
- an argument allows only one-way information flow
  - it’s data that goes into the function, not out
  - the only data that comes out is via the return value
- but we can be sneaky…
  - before we passed in data values
  - but we can also pass in pointers, that point to data values
    - the function can change what’s at the address that was passed in
    - and the calling code can then retrieve the changes

also last week…

we talked about the concept of extent
- describes when a variable exists
  - that is, when memory is being used for the variable
- complements the concept of scope, which we introduced a while ago
extent is important now
- without pointers, it’s less important
  - because whenever the variable is in scope, it exists
  - but now that we have pointers, we can potentially have a pointer to a variable that has ceased to exist

arrays

so far, we have been using only scalar variables
- "scalar" meaning a variable with a single value
but many things require a set of related values
- coordinates or vectors require 3 (or 2, or 4, or more) values
- text requires a long list of characters in a specified order
- spreadsheet data is often a long list of numbers

what is an array?

the spec says: "...a continuously allocated nonempty set of objects with a particular member object type"
in real language: a bunch of things of the same type
- each value is like a little variable
- but all you really need to know is
  - where the array starts (a pointer, usually)
  - what type of data is in the array
    - all elements of an array are always the same data type
  - how many elements are in the array

example

so let’s say I want to write a program to compute the average, median, and standard deviation for the midterm exam
- I want to be able to reuse this program every term, so I can’t build in a knowledge of how many students there are in the class
- what I’d like is a program where just keep entering scores until I’ve entered them all
  - I could have a nonsense input, like –1, to signal that I’ve entered all of the scores

scores example

so let’s keep things simple: imagine there are only 5 students in my class
- they get the following scores on an exam: 57, 85, 97, 16, 82
- this is what I’d like my program to do:
Scores: a program to compute grade statistics. Enter all scores, finish with –1: 57 85 97 16 82 –1 Average: 61.4 Median: 82 Standard Deviation: 32.2

how can we do that?

since we don’t know how many scores will be entered, we can’t know how many variables to create
- this will actually be a problem anyway, so we’ll have to build in a maximum class size
- let’s say there will never be more than 250 students in a class
- but still, the program will be awkward at best, since we have to read in an arbitrary number of values, and then add them up

so look at this example

#include <stdio.h>

int InputScores (double *);
void PrintStats (double *, int);

int main (void)
{
  double scores[250];
  int numScores;

  printf ("Scores: a program to compute grade statistics.\n");
  printf ("Enter all scores, finish with –1:\n\n");

  numScores = InputScores (scores);
  PrintStats (scores, numScores);
}

array declaration

double scores[250];

this declares a variable named "scores"
- it is an array of 250 doubles
- thus, it reserves enough memory for 250 contiguous doubles (1000 bytes)

array declarations

as with other declarations, array variable declarations include:
- a data type
- a variable name
- ends with a semicolon
but in addition, an array declaration has:
- a length, enclosed in square brackets
  type name[length];
- we say that name has the type "array length of type"
  - so in our previous example, scores is "array 250 of double"

initialization

as with other declarations, array declarations can include an optional initialization
- scalar variables are initialized with a single value
- arrays are initialized with a list of values
  - the list is enclosed in curly braces
  int array [8] = {2, 4, 6, 8, 10, 12, 14, 16};

more about initialization

the number of initializers cannot be more than the number of elements in the array
- but it can be less
- in which case, the remaining elements are initialized to 0
if you like, the array size can be inferred from the number of initializers
- by leaving the square brackets empty
- so these are identical declarations
  int array1 [8] = {2, 4, 6, 8, 10, 12, 14, 16}; int array2 [] = {2, 4, 6, 8, 10, 12, 14, 16};

but what does this do?

int array [8] = {2, 4, 6, 8, 10, 12, 14, 16};

what can we do with arrays?

all well and good, but how do we use arrays?
there are two main things you can do with an array:
- you can refer to an element in the array
- you can get the address of the first element in the array (and all the rest)

array elements

when we refer to an array element, we use a subscript expression:
- the operator is the square bracket pair [ ]
- the operands are the array variable, and the index expression
  int array[] = {2, 4, 6, 8, 10, 12, 14, 16}; int i; for (i = 0; i < 8; ++i) printf("%d", array[i]);

subscript expression

some details about the subscript expression
- for an array N of T, the data type of the subscript expression is T
  - that is, the data type of array[i] is int
- the expression inside the square brackets must have integral type
  - that is, it can be char, short, int, or long
  - but not double, float, long double, a pointer, an array, …

address of first element

when we use the array name in any value context, it is converted into a pointer to the first element of the array
- what’s a value context?
  - any use where the expression simply retrieves the value, and doesn’t try to modify it
- the type of the pointer is "pointer to T"
  - when the array type is "array N of T"

The Rule

In a value context, the name of an array of type "array N of T" becomes a "pointer to T"
Remembering this rule will make arrays and pointers seem much more sensible
Forgetting this rule will make them confusing

example

#include <stdio.h>

int main (void)
{
  int array [8] = {2, 4, 6, 8, 10, 12, 14, 16};
  int *p1, *p2;

  p1 = array;
  p2 = &array[0];

  printf ("%d  %d\n", *p1, *p2);
  return 0;
}

our story so far…

this material roughly corresponds to parts of section 5.3
an array is a group of one or more adjacent things in memory
- they are all the same type
  - any of the 7 basic data types
  - pointers
  - arrays (we won’t tackle this yet)
  - other things we haven’t learned about

array recap: array declarations

we have to declare an array variable just like any other variable
- type name[size];
- type name[size] = { initializer list};
- type name[] = { initializer list };
- common elements:
  - type: the data type of each element of the array
  - name: the name of the variable we are declaring
  - size: either explicit or implicit, it’s the number of elements

array recap: array definitions

as with other declarations, a defining declaration will reserve storage
- this will allocate an adjacent block of memory large enough to store all elements of the array
- all of the declarations we’ve seen (and probably will see) have been definitions

array declaration examples

some examples of array declarations

array recap: using arrays

we can only do two things with arrays:
- refer to an element of the array
  - we can then do lots of different things with that element
- get a pointer to the first element of the array

array recap: subscript expression

we refer to an array element using a subscript expression
- array_name[index]
- details
  - the index is any expression with integral value
  - the index value selects a specific element of the array
    - the first element is index 0
  - a subscript expression is usually an lvalue
    - which means we can assign a value to an array element

array recap: subscript expression

given the following declaration:
- it’s not illegal to use an index off the end of the array
  - but it may have undefined results, since it will mean you’re referring to memory that isn’t part of the array
  - we’ll see why this is legal a little later…

subscript expression examples

so remember our example declarations:

double coord[3];
int frequency [26];
int *pointer [6];

the following code is legal:

printf ("(%f, %f, %f)\n", coor[0], coor[1], coor[2]);
for (i=0; i<26; ++i)
  frequency[i] = 0;
pointer[3] = &frequency[12];

array recap: array name as pointer

in many contexts, using the array name by itself gets you a pointer to the first element

int frequency [26];
int *pointer [6];
pointer[3] = &frequency[12];
pointer[2] = frequency;

so now back to our example

#include <stdio.h>

int InputScores (double *);
void PrintStats (double *, int);

int main (void)
{
  double scores[250];
  int numScores;

  printf ("Scores: a program to compute grade statistics.\n");
  printf ("Enter all scores, finish with –1:\n\n");

  numScores = InputScores (scores);
  PrintStats (scores, numScores);
}

Note that we call the two functions with the argument scores

passing arrays

it is perfectly legal to put an array name into a list of arguments to a function
- this is a value context
- therefore, the array name expression becomes a pointer to the first element of the array
- note that the prototype for InputScores looks like this:
  int InputScores (double *);
so when we pass an array into a function, we’re really just passing a pointer to the beginning of the array

passing arrays

note the "difference" between passing a scalar variable and an array
- up to now, when we put a variable name in an argument list, its value was passed to the function
- with an array, what gets passed is a pointer
there’s no discrepancy here, really…
- remember the array rule:
  - In a value context, the name of an array of type "array N of T" becomes a "pointer to T"
- so in a manner of speaking, the "value" of the variable is the pointer to the first array element.

functions with array arguments

we’ve talked about passing arrays into functions, but what does it look like from the function side?
- the function gets a pointer as an argument.
  - but we only know how to dereference a pointer to a single value
  - how does the function access the whole array?

arrays and pointers

here’s where we start getting into the real overlap between arrays and pointers
- remember I told you The Rule:
  - In a value context, the name of an array of type "array N of T" becomes a "pointer to T"
- and remember the syntax of the subscript expression
  - array_name [index]
- in fact, there’s nothing special about this use of the array name – it’s simply a value context too

say what?

a subscript expression is really a pointer expression, not an array expression
- and to understand this, we have to delve into pointer arithmetic

pointers again

so far, we have discussed three operators that deal with pointers:
- the "address-of" operator: &
- the dereference operator: *
- the assignment operator
there are other pointer operators you can use, including:
- addition: +
- subtraction: -

pointer arithmetic

the familiar arithmetic operators + and – can also be used with pointers
- but there are rules…
- I said that computer addresses are just numbers, but pointer arithmetic isn’t quite as simple as that…

pointer addition

one of the operands of + can be a pointer
- but then the other operand must be an integer
- and it doesn’t just add the integer to the address
  - instead, it adds the integer times the size of the thing the pointer points to
- so given the declarations:
  int i; int *p = &i;

the logic of pointer addition

why do things work this way?
- remember, things are different sizes on different computers
  - so we can’t build into our programs an assumption that, say, ints are always 4 bytes long
- plus, there’s array indexing…
  - you can step through an array by simply incrementing a pointer
  - adding 1 to a pointer gets you to the next "thing" in the array
    - whether it’s actually pointing to an array or not

pointer addition and array indexing

so given an array declared like this:
- remember that using the array name by itself just gets a pointer to the first element
- that means:
  - a is equivalent to &a[0]
  - *a is equivalent to a[0]
- now if we mix in pointer addition:
  - a+1 is equivalent to &a[1]
  - *(a+1) is equivalent to a[1]

pointer addition and array indexing

in fact, the C language defines the subscript expression in terms of pointer addition
- that is, the expression a[b] is identical to *(a+b)
so back to the original reason we brought up pointer addition:
- you can use an array name or a pointer in a subscript expression, because to C it’s the same thing
  - it all becomes pointer arithmetic

some more details of pointer addition

if one operand of + is a pointer, the other operand must be an integer type
- you cannot add two pointers
- the data type of the expression is the same type as the pointer
it doesn’t matter what order you add the operands
- p+i is the same as i+p

back to that locker analogy

Remember I’ve said that pointers are like locker numbers
- pointer addition, then, is like finding a locker relative to another one
  - "5 lockers to the right of #371"
- and as with pointer addition, it doesn’t make sense to add two locker numbers together

Maintained by Efi Fogel. Last modified: January 25 2003.