Internal Representation of Arrays in C

Motivation

Fully understanding how arrays work in C requires some understanding of how they are represented in the computer's memory.

In C, an array will be implemented as a single block of memory, with element 0 occupying the first "slot" in that block. As a result, C subscripts are closely related to actual memory addresses, and to the notion of "pointer".

Possible dire consequences from the misuse of arrays should motivate you to pay close attention to the array indices.

Bits, bytes and words

A bit is one binary digit , i.e. a 0 or a 1.
A byte is nominally eight bits, or the amount of memory needed to hold one character.
A word is a collection of bytes, the number of which varies depending on the type of computer. Typical values these days are 2, 4 and 8 bytes to a word. (e.g., 16, 32 or 64 bit words).
A word is usually the amount of memory the computer uses to represent a regular integer and is also usually the smallest segment of memory that most low-level operations are designed to handle.

Beyond words, we speak of

kilobytes
megabytes
gigabytes

of memory.

Memory addresses

Each memory locations in a computer is identified by a unique numeric address.

Typically, these are integers which begin with 0 for the first byte in memory and count upward from there.

Some data elements need more than one byte to store.

For example, an integer on an SGI computer might be encoded using four consecutive bytes and a double using eight bytes.

Such data values are indexed by the location of the first byte of their encoding.

The sizeof operator

    sizeof(type) returns the number of bytes needed
                 to represent a value of that type.

    sizeof x     returns the number of bytes needed 
                 to store the value of the variable x.

Allocation of memory to variables

When you declare a variable, the complier allocates memory locations in which to place its value.

Global variables are allocated when the program begins and persist until the program ends.
A local variable for function FOO is allocated when FOO is called and released when FOO returns.

For a simple variable (e.g., int, double) of type X the compiler allocates sizeof(X) bytes to hold it.

For an array of length L and type X , the compiler allocates L*sizeof(X) bytes.

Given an array like int scores[100] , the compiler allocates 400 bytes starting at some location, say 64789.

Given an expression like scores[5] the compiler accesses the value stored at the memory location starting with byte 64789+(5*4).

In general, foo[i] is located at byte:


 base address of foo  +  i * sizeof (type of array)

References to elements outside of the array bounds

C will not flag as an error a reference past the end of the array.

scores[9999] will try to access some random words in memory.

References to elements outside of the array bounds is one very common cause of sementation faults and core dumps.

Thursday, 01-Oct-1998 17:57:11 EDT