C Programming
Lecture 14
Arrays
What is an Array?

An array is a sequence of data
items that are:
• all of the same type
– a sequence of integers, or a sequence of
characters, or a sequence of floats, etc.
• indexible
– you can indicate or select the first
element or second element or ...
• stored contiguously in memory
– each element of the sequence is stored in
memory immediately after the previous
element
One-Dimensional Arrays

Declaration of a one-dimensional
array.
• int grade[3];
– Provides space in memory to store three
grades (as in grades on three of your
quizzes)

Example of Assignments
grade[0] = 95;
grade[1] = 88;
grade[2] = 97;
/* 1st element index is 0 */
/* 2nd element index is 1 */
/* 3rd element index is 2 */
Accessing Array Elements

The following code segment will print
the three grades stored in the array on
the previous slide (assume i has been
declared as an int variable):
for (i = 0; i < 3; ++i)
printf(“Grade %d is %d\n”, i, grade[i]);

Output
Grade 0 is 95
Grade 1 is 88
Grade 2 is 97
Arrays and Pointers


An array name is also the name of a
pointer constant to the base address
(beginning) of the array in memory.
Using “made up” addresses (as we have
before in discussing pointers):
grade 1000 1004 1008 < addresses in memory
95
88
97
values stored in
each element
0
1
2 < index of array element
The address stored in grade would be 1000
Using a Symbolic Constant
as the Size of the Array

It is considered good programming
practice to define the size of an
array as a symbolic constant:
• In the next example, if the size of a
class changes then the symbolic
constant at the top of the program is
easily changed.
• The program would then be recompiled
so it can be used with the larger
array of grades.
Example of Entering Values into an Array, then Displaying the Values
#include <stdio.h>
#define N
20
/* Number of students in class */
int main(void)
{
int grade[N];
int i;
/* declare array with N elements */
/* Enter the grades for a quiz */
for (i = 0; i < N; ++i) {
printf(“Enter quiz grade %d: “, i + 1);
scanf(“%d”, &grade[i]);
}
/* display the grades that were entered */
printf(“Here are the grades that were entered\n”);
for (i = 0; i < N; ++i)
printf(“Grade %d is %d”, i + 1, grade[i]);
}
Note that the user is shown grades starting with grade 1,
but what the user thinks of as grade 1 is stored in
grade[0] in the array.
Initialization of Arrays
As with simple variables, arrays can be
initialized within a declaration.
• An array initializer is a sequence of
initializing values written as a braceenclosed, comma-separated list.
float x[4] = {-1.1, 0.2, 33.0, 4.4};
x[0] is initialized to -1.1
x[1] is initialized to 0.2
etc.
More on Initialization of Arrays



If a list of initializers is shorter
than the number of array elements, the
remaining elements are initialized to
zero.
If an external or static array is not
initialized, then the system
automatically initializes all elements
to zero.
Uninitialized automatic and constant
arrays start with garbage values -whatever happens to be in memory when
the array is allocated.
Declaring and Initializing
an Array Without a Size

If an array is declared without a size
and is initialized to a series of
values, it is implicitly given the size
of the number of initializers.
int a[] = {3, 4, 5, 6};
is equivalent to
int a[4] = {3, 4, 5, 6};
Range of Values
Allowed for a Subscript
Assume a declaration:
int
i, a[size];
 To access an element of the array,
we can write a[expr], where expr
is an integral expression.
 expr is called a subscript and the
value of the subscript must lie in
the range 0 to size - 1.

“Subscript Out of Bounds”

If a subscript from the previous
example lies outside the range 0
to size - 1 then:
• A run-time error occurs.
• The system will stop executing your
program and display a message such as
“subscript out of bounds”.
• Sometimes no error message is
displayed, but your program will
begin to produce unexpected results.
Relationship Between
Arrays and Pointers

An array name represents the address of
the beginning of the array in memory.
• When an array is declared, the compiler must
allocate a base address and a sufficient
amount of storage (RAM) to contain all the
elements of the array.
• The base address of the array is the initial
location in memory where the array is
stored.
– It is the address of the first element
(index 0) of the array.
Passing Arrays to Functions

In a function definition, a formal
parameter that is declared as an
array is actually a pointer.
• When an array is passed, its base
address is passed call-by-value.
• The array elements themselves are not
copied.
• As a notational convenience, the
compiler allows array bracket
notation to be used in declaring
pointers as parameters.
Example of Passing an Array to a Function
int sum(int a[], int n)
{
int
i, s = 0;
/* n is size of the array */
Notice -- no size here. That
was provided in the original
for (i = 0; i < n; ++i) declaration of the array.
s += a[i];
return s;
}
alternative function definition:
int sum(int *a, int n)
{
int
i, s = 0;
/* n is size of the array */
for (i = 0; i < n; ++i)
s += a[i];
return s;
}
Equivalence of int a[]; and int *a;
As part of the header of a
function definition the
declaration
int a[]; is equivalent to int *a;
 Within the body of a function,
these are not equivalent.

• The first will create a constant
pointer (and no storage for an array).
• The second will create a pointer
variable.