Books / C Language Primer for Java Developers / Chapter 4
Arrays in C vs Java
An array is a data structure consisting of a collection of elements or values, each identified by unique index. There are multiple ways to create an array in C. The methods shown in this section are easier to use, but they result in arrays that are not permanent.
This code creates a new array of 20 ints called myArray
:
int myArray[20]; // array of 20 ints
Usually the elements of this array are not initialized. Do not assume that they all start out holding 0.
Alternatively, we can also leave out the size but include the elements explicitly:
int fib[] = {0, 1, 1, 3, 5, 8, 13, 21, 34, 55}; // 10 ints
This results in an array of size 10, holding the first numbers of the Fibonacci sequence.
The problem with these arrays is that they are treated like local variables. They will cease to exist after the function they’re in has ended. Thus, these techniques cannot be used if the array needs to be permanent. Trying to return these arrays, or use them after the function has stopped, can result in strange errors in which your program terminates or unrelated data gets changed, seemingly at random. We will discuss this further when we talk about memory and pointers. We will also discuss a way to make a permanent array.
What’s more, you must be very careful when indexing an array in C.
In Java, you immediately get an ArrayIndexOutOfBoundsException
when
you try to access an illegal element in an array. For example, the
array fib
that we created has only 10 elements: fib[0]
through
fib[9]
. If you tried to access fib[10]
or fib[-1]
, your Java
program would immediately stop and let you know there was a problem. C
has no such boundary checking: if you tried to access fib[10]
, C
would just look at the memory where fib[10]
would be if it
existed, and return that data as if it were an int. Even worse, if
you mistakenly wrote to fib[10]
, it would change the data where
fib[10]
would be—altering some unrelated data! Be careful!
Another issue is that C arrays do not have a length
property, unlike
in Java. There is no way to calculate the length of the array from the
array itself. If the length of an array can vary, its length must
be stored in a int
. It is very common when one writes a function that takes an
array as an argument, that it has a second argument indicating that array’s
length:
// this function has an array argument & a length argument
int doThingWithArray(int array[], int arrayLength) {
}
Some people might try to do a
sizeof(myArray)
. However, this will only work from inside the same function as the array was declared, and only if done using one of these”temporary” methods. It usually only tells you the size of the array’s address in memory, which is not helpful.