• Home
• Syllabus
• Schedule
• Connect
• Checkin
• Homework
  • HW0
  • HW1
  • HW2
  • HW3
  • HW4
• Piazza
• Slides
• Other Info

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 UPPERCASE letters.

Constants via #define

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

#define PI 3.1415926
printf("%f\n", PI);

3.141593

#define PI 3.1415926
PI = 3.0;

c.c: In function 'main':
c.c:2: error: lvalue required as left operand of assignment

• #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:

#define MAX_NUM_STUDENTS 5
int grades[MAX_NUM_STUDENTS];
for (int i = 0; i < MAX_NUM_STUDENTS; i++)
    grades[i] = i*12;
for (int i = 0; i < MAX_NUM_STUDENTS; i++)
    printf("%d ", grades[i]);

0 12 24 36 48 

    ┌───────────┬───────────┬───────────┬───────────┬───────────┐
    │     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];
printf("sum=%d\n", sum);

sum=15

Array Example, 1/3: Read

    #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

    #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

    #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

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

Indices Out of Range

• 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[] = {1,2,3};
for (int i=0; i<20; i++)
    printf("%d ", scores[i]);

1 2 3 3 4195824 0 -596791931 32751 -595435608 32751 -885631096 32764 0 1 4195734 0 0 0 -1996347715 -570159896 

Sometimes, you get away with it.

Sometimes, you get away with breaking the rules:

int a[10];
a[12] = 456;
printf("%d\n", a[12]);

456

Sometimes, you don't:

int a[10];
a[1000006] = 789;
printf("%d\n", a[1]);

c.c: In function 'main':
c.c:3: warning: 'a[1]' is used uninitialized in this function
SIGSEGV: Segmentation fault

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

#define MAXELEMENTS 5

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

int main() {
    double numbers[MAXELEMENTS] = {1.2, 3.4, 5.6, 7.8, 9.0};
    printf("%lf\n", average(numbers, MAXELEMENTS));
    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; 
}

5.400000

Passing 1-D Array: Examples

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

int main() {
    int a[] = {11, 22, 33, 44, 55};
    printf("total: %d\n", sum(a, 5));
    return 0;
}

total: 165

Passing 1-D Array: Examples

A recursive function to add an array:

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

int main() {
    int a[] = {11, 22, 33, 44, 55};
    printf("total: %d\n", sum(a, 5));
    return 0;
}

total: 165

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

• Arguments are passed by value, right? A copy is made?
• So what happened?

Arrays as Function Parameter

• Arrays are passed by reference. A copy is not made.
• 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 function actually is a change in the my_list array in the main function (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.

void foo(int oneval) {
    oneval = 99;
}

int main(){
    int hula[] = {1,2,3,4,5};
    printf("before: %d\n", hula[0]);
    foo(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

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

• Indices go from 0 to (size-1).
• Be careful not to access beyond the end of an array.
• 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”.

User: Guest

Apply to CSU | Contact CSU | Disclaimer | Equal Opportunity
Colorado State University, Fort Collins, CO 80523 USA
© 2018 Colorado State University