See this page as a slide show

CS156 Arrays: Arrays

Some slides from Syracuse University

Multiple Variables of Same Type

• Sometimes we need to use a number of variables of the same type, for the same purpose.
• We sometimes call this a list.
• For example, we may hold each student's grade (an integer 0–100) in variables called grade1, grade2, grade3, ...
• This may require many int variables.
• The program would have to handle these variables one by one.
• Better: Use arrays to group the values together.

Arrays

• Data structure (list) that hold multiple variables of the same data type
• Can be single-dimensional or multi-dimensional
• 1-D example:

             homework scores
    ┌───────┬───────┬───────┬───────┐
    │ hw #1 │ hw #2 │ hw #3 │ hw #4 │
    └───────┴───────┴───────┴───────┘

Array Declaration

• An array declaration specifies
  • the type of its elements (the base type)
  • the array’s name,
  • the number of elements the array holds
• Example: int grades[5];
• A better way, use a constant instead of a literal value:
  #define MAX_NUM_STUDENTS 5
int grades[MAX_NUM_STUDENTS];
• #define allows us to define constants—variables that do not change.
• By convention, constant names are all upper-case letters.

const

• The #define keyword tells the compiler that the following “variable” declaration/initialization will remain constant throughout the program.

        #define PI 3.14159
        PI = 3.0;        // Wrong wrongity wrong!

• #define ints can be used as size parameters in the declaration of arrays. This is useful for creating code that is easily modified.

Array Manipulation

• Accessing elements of an array is called indexing or subscripting
• An index or subscript is the element’s position in the array
• Mathematical notation: a_n.
• C notation: a[n].
• The elements of an array are allocated contiguously (no gaps)
• Each individual element of an array is numbered consecutively, starting from 0.

Array Manipulation - Initialization

The last element in the array is at index N-1, where N is the number of elements in the array.

    #define MAX_NUM_STUDENTS 5
    int grades[MAX_NUM_STUDENTS];
    grades[0] = 98;
    grades[1] = 87;
    grades[2] = 92;
    grades[3] = 79;
    grades[4] = 85;

    ┌───────────┬───────────┬───────────┬───────────┬───────────┐
    │ grades[0] │ grades[1] │ grades[2] │ grades[3] │ grades[4] │
    └───────────┴───────────┴───────────┴───────────┴───────────┘

Array Manipulation - Initialization

Three ways to do the same thing:

    #define MAX_NUM_STUDENTS 5
    int grades[MAX_NUM_STUDENTS] = {98, 87, 92, 79, 85};

    int grades[] = {98, 87, 92, 79, 85};

    int grades[5];
    grades[0] = 98; grades[1] = 87;
    grades[2] = 92; grades[3] = 79;
    grades[4] = 85;

    ┌───────────┬───────────┬───────────┬───────────┬───────────┐
    │    98     │    87     │    92     │    79     │    85     │
    └───────────┴───────────┴───────────┴───────────┴───────────┘
      grades[0]   grades[1]   grades[2]   grades[3]   grades[4]

Array Manipulation

Uninitialized array elements contain unknown values, like all variables.

    #define MAX_NUM_STUDENTS 5
    int grades[MAX_NUM_STUDENTS];
    grades[3] = 10+6+42;

    ┌───────────┬───────────┬───────────┬───────────┬───────────┐
    │    ??     │    ??     │    ??     │    58     │    ??     │
    └───────────┴───────────┴───────────┴───────────┴───────────┘
      grades[0]   grades[1]   grades[2]   grades[3]   grades[4]

Array Manipulation

• It is common to process the elements of an array in a loop, with one element processed per loop iteration
• The most convenient iteration statement for this is the for statement, since the loop header encapsulates both the initialization and the use of an index variable:

    // Initialize:
    for (int i = 0; i < MAX_NUM_STUDENTS; i++)
        grades[i] = i*12;
    // Print:
    for(int i = 0; i < MAX_NUM_STUDENTS; i++)
        printf("%d ", grades[i]);

    ┌───────────┬───────────┬───────────┬───────────┬───────────┐
    │     0     │    12     │    24     │    36     │    48     │
    └───────────┴───────────┴───────────┴───────────┴───────────┘
      grades[0]   grades[1]   grades[2]   grades[3]   grades[4]

for Loops and Arrays

• for loops are often used to do things with the elements of an array.
• Remember, the elements are indexed starting from 0.

    // sum the elements of an array
    #define ARRAY_SIZE 5
    int my_list[ARRAY_SIZE] = {1,2,3,4,5};
    int sum = 0;
    for (int counter=0; counter < ARRAY_SIZE; ++counter)
            sum += my_list[counter];

Array Example, 1/3: Read

    #include <stdio.h>
    #define SIZE 3
    int main() {
        double a[SIZE];
        printf("Enter numbers: ");
        for (int i = 0; i < SIZE; i++)
            scanf("%lf", &a[i]);
        return 0;
    }

    Enter numbers: 1.2 3.4 5.6

Array Example, 2/3: Print

    #include <stdio.h>
    #define SIZE 3
    int main() {
        double a[SIZE] = {1.2, 3.4, 5.6};
        /* Display array elements */
        for (int i = 0; i < SIZE; i++)
                printf("a[%d] = %.2lf\n", i, a[i]);
        return 0;
    }

    a[0] = 1.20
    a[1] = 3.40
    a[2] = 5.60

Array Example, 3/3: Max

    #include <stdio.h>
    #define SIZE 3
    int main() {
        double a[SIZE] = { 1.2, 3.4, 5.6 };
        double max = 0.0;
        /* Find max value in array */
        for (int i = 0; i < SIZE; i++)
            if (a[i] > max)
                    max = a[i];
        printf("max = %.2lf\n", max);
        return 0;
    }

    max = 5.60

Array Example, Combined

    #include <stdio.h>
    #define SIZE 3
    int main() {
        double a[SIZE];
        double max = 0.0;
        printf("Enter the %d array elements\n", SIZE);
        for(int i = 0; i < SIZE; i++)  /* Read the array elements */
            scanf("%lf", &a[i]);
        for(int i = 0; i < SIZE; i++)  /* Display array elements */
            printf("a[%d] = %.2lf\n", i, a[i]);
        for(int i = 0; i < SIZE; i++)  /* Find max value in array */
            if (a[i] > max)
                max = a[i];
        printf("max = %.2lf\n", max);
        return 0;
    }

Array Manipulation

• Warning!
• C doesn’t perform range-checking of indices.
• Checking index values is your problem.
• If an array index is out of bounds, the results are unpredictable.

int scores[ ] = { 92, 87, 95 };
for (int i=0; i<=9; i++)
        scanf("%d", &scores[i]);

int grades[3];
grades[53] = 98;
grades[5] = 98;

Arrays as Function Parameters

• C allows arrays to be passed to functions as arguments, so that a function may operate on different arrays with each call

Passing 1-D Arrays to Functions

• Passing arrays into functions uses the syntax we would expect:
  type function(type array name[])
• Note, however, that we have no way of knowing the size of the array unless we tell the function.
• So generally we pass an array and another argument that is the length of the array.

Arrays as Function Parameters

    #include <stdio.h>
    #define MAXELEMENTS 5

    double average(double a[], int numberOfElements) ;

    int main() {
        double numbers[MAXELEMENTS] = {1.1, 2.2, 3.3, 4.4, 5.5};
        double ave = average(numbers, MAXELEMENTS);
        printf("%lf\n", ave);
        return 0;
    }

    double average(double a[], int numberOfElements) {
        double sum = 0.0;
        for (int i=0; i<numberOfElements; i++) 
            sum += a[i]; 
        return sum / numberOfElements; 
    }

Passing 1-D Array: Examples

    int sum_list(int list[], int size) {
        int sum=0;
        for (int i=0; i<size; i++)
            sum += list[i];
        return sum;
    }

    int recursive_sum_list(int list[], int size);
        if (size == 1)
            return list[0];
        return list[size-1] + recursive_sum_list(list, size-1);
    }

Passing 1-D Array: Another Example

void change_list(int list[], int size) {
    list[0] = 10;
}
int main() {
    int foo[5] = {1,2,3,4,5};
    printf("before: %d\n", foo[0]);
    change_list(foo, 5);
    printf("after: %d\n", foo[0]);
    return 0;
}

before: 1
after: 10

What gives?

Arrays as Function Parameter

• Arrays are passed by reference
• The address is passed to the function—it does NOT make a copy of the entire array!
• That means that any change to an element of the list array in the change_list method actually is a change in the my_list array in the main method (based on previous slide example)
• Reason: it would take a lot of memory and time to pass large arrays if we made a copy of it every time we wanted to send it to a function.

Passing array elements

• We can also pass an element of an array to a function.
• It’s treated as a single variable.

#include <stdio.h>
void callFunc(int oneval) {
    oneval = 99;
}
int main(){
    int hula[] = {1,2,3,4,5};
    printf("before: %d\n", hula[0]);
    callFunc(hula[0]);
    printf("after: %d\n", hula[0]);
    return 0;
}

before: 1
after: 1

• What’s the difference between this and the previous example?

Passing array elements

#include <stdio.h>
void print(int list[], int size)  {
    for (int i=0; i<size; i++)
        printf("%d ", list[i]);
    printf("\n");
}
void  swapFirstLast(int list[], int size)  {
    // What goes here?
}
int main()  {
    #define LIST_SIZE 5
    int my_list[LIST_SIZE] = {1,2,3,4,5};
    print(my_list, LIST_SIZE);
    swapFirstLast(my_list, LIST_SIZE);
    print(my_list, LIST_SIZE);
    return 0;
}

• If the list were: 1 2 3 4 the list will change to 4 2 3 1
• Fill in swapFirstLast.

Passing array elements

• Write a program that makes a full copy of an array.

Array Tips

• Be careful not to access beyond the end of an array.
• Indices go from 0 to (size-1)
• While this will not cause a syntax error, it will cause unexpected and undefined behavior.
• While technically unbounded, the size of possible arrays is limited by hardware of a machine.
• Elements of an array are not initialized by default, so the values can be unpredictable.
• You cannot copy all the elements of one array into another with an assignment statement. You need to write a loop.

Array Tips

• The most common logic error associated with arrays is an invalid index.
• An invalid index used with an assignment operator either causes the program to fail immediately or destroys data or code in another part of the program and causes it to fail later. Hard to debug! Unpredictable!!
• Array indices must be integers, not floating-point numbers or strings.
• The plural of “index” is “indices”.