Question

I am using Code::Blocks 10.05, and the GNU GCC Compiler.

Basically, I ran into a really strange (and for me, inexplicable) issue that arises when trying to initialize an array outside it’s declared size. In words, it’s this:

*There is a declared array of size [x][y].

*There is another declared array with size [y-1].

The issue comes up when trying to put values into this second, size [y-1] array, outside of the [y-1] size. When this is attempted, the first array [x][y] will no longer maintain all of its values. I simply don’t understand why breaking (or attempting to break) one array would affect the contents of the other. Here is some sample code to see it happening (it is in the broken format. To see the issue vanish, simply change array2[4] to array2[5] (thus eliminating what I have pinpointed to be the problem).

#include <stdio.h>

int main(void)
{
    //Declare the array/indices
    char array[10][5];
    int array2[4]; //to see it work (and verify the issue), change 4 to 5
    int i, j;

    //Set up use of an input text file to fill the array
    FILE *ifp;
        ifp = fopen("input.txt", "r");

    //Fill the array
    for (i = 0; i <= 9; i++)
    {
        for (j = 0; j <= 5; j++)
        {
            fscanf(ifp, "%c", &array[i][j]);
            //printf("[%d][%d] = %c\n", i, j, array[i][j]);
        }
    }

    for (j = 4; j >= 0; j--)
    {
        for (i = 0; i <= 9; i++)
        {
            printf("[%d][%d] = %c\n", i, j, array[i][j]);
        }
        //PROBLEM LINE*************
        array2[j] = 5;

    }

    fclose(ifp);
    return 0;

}

So does anyone know how or why this happens?

Answer 1

Because when you write outside of an array bounds, C lets you. You’re just writing to somewhere else in the program.

C is known as the lowest level high level language. To understand what “low level” means, remember that each of these variables you have created you can think of as living in physical memory. An array of integers of length 16 might occupy 64 bytes if integers are size 4. Perhaps they occupy bytes 100-163 (unlikely but I’m not going to make up realistic numbers, also these are usually better thought of in hexadecimal). What occupies byte 164? Maybe another variable in your program. What happens if you write to one past your array of 16 integers? well, it might write to that byte.

C lets you do this. Why? If you can’t think of any answers, then maybe you should switch languages. I’m not being pedantic – if this doesn’t benefit you then you might want to program in a language in which it is a little harder for you to make weird mistakes like this. But reasons include:

• It’s faster and smaller. Adding bounds checking takes time and space, so if you’re writing code for a microprocessor, or writing a JIT compiler, speed and size really do matter a lot.
• If you want to understand machine architecture and go into hardware, e.g. if you’re a student, it’s a good gateway from programming into OS/hardware/electrical engineering. And much of computer science.
• Being close to machine code, it’s standard in a way that many other languages and systems have to, or can easily, support some degree of compatibility with.
• Other reasons that I would be able to give if I ever actually had to work this close to the machine code.

The moral is: In C, be very careful. You must check your own array bounds. You must clean up your own memory. If you don’t, your program often won’t crash but will start just doing really weird things without telling you where or why.