即使在数组中添加更多具有值的元素后，数组的大小也保持不变

Question

this is just something I picked up while playing around with some code today. I am still a C newbie, please be kind.

The code below is basically taking an array with only one element and checking its size and value (4 and 0 respectively). It then creates new elements in the array and assigns values to these new elements before checking the size of the array again.

What i find is that the array does not increase in size. If I create the array with 5 elements from start, the array size is 20. If i create only 1 element from start and add the other 4 later, the array size stays at 4 but still holds 5 elements with values.

Could somebody explain why this happens? Is this a safe way of assigning values to an array while saving space? Or is there something wrong with this?

Am i missing something?

If I have posted this in the wrong Stack Exchange forum, please let me know so I can delete it and ask it somewhere else, thanks.

#include <stdlib.h>
#include <stdio.h>
#include <string.h>

int main()
{
    int n = 5; 
    char temps[257] = "1 -2 -8 4 5\n"; 
    int arr[1] = {0};
    int c;   

printf("\n-- START of Test area --\n\n");

// sizeof arr = 4
printf("Initial sizeof(arr) = %d\n\n", sizeof(arr));

// Initial values of arr
printf("Value of arr[0] = %d\n", arr[0]);    // 0
printf("Value of arr[1] (no value assigned) = %d\n", arr[1]);    // random number
printf("Value of arr[2] (no value assigned) = %d\n\n", arr[2]);    // Random number

// sizeof arr = 4
printf("sizeof(arr) = %d\n\n", sizeof(arr));

// -- Creates new array elements and assigns values using temps 
sscanf(temps, "%d\n %d\n %d\n %d\n %d\n", &arr[0], &arr[1], &arr[2], &arr[3], &arr[4]);    

printf("New array elements and values using temps\n\n");
printf("Value of arr[0] = %d\n", arr[0]);  // 1
printf("Value of arr[1] = %d\n", arr[1]);  // -2
printf("Value of arr[2] = %d\n", arr[2]);  // -8
printf("Value of arr[3] = %d\n", arr[3]);  // 4
printf("Value of arr[4] = %d\n", arr[4]);  // 5
printf("Value of arr[5] = %d\n\n", arr[5]);  // 0

// Sizeof array = 4
printf("sizeof(arr) = %d\n\n", sizeof(arr)); 

printf("\n-- END of Test area --\n\n");

    return 0;
}

Answer 1

Once an array is declared you can't add or subtract any element to it, but can modify.
One more thing is that arr is of size 1 and you are accessing array out of bound in some statements like

sscanf(temps, "%d\n %d\n %d\n %d\n %d\n", &arr[0], &arr[1], &arr[2], &arr[3], &arr[4]); 

It invokes undefined behavior.

Answer 2

An array by definition is a block of contiguous memory. That means you can only tell the compiler about the size of the array one time and it will allocate memory for your array.

For example if you write int n[10]; the compiler will reserve memory on the stack for 10 integer values (for example 8 bytes for each int).

In this case n[9] is the last element that your array holds, since n[0] is the first.

let me explain this in more detail: n is actually the memory address of the first element of the array. in fact n[0] and n have the same memory address. if you have int i; to denote the index of array you like to access:

n[i] tells the compiler to look at memory location n + (i * sizeof(int));

the compiler knows the type of array, so it knows how to calculate the appropriate address when you use n[i];

now if i is not valid, the compiler will come up with a memory address that might contain garbage, or you may not have access to. This will cause you problems if you are not careful.

since C is somewhat of a lower level language, it does not support array bounds checking and it does not keep track of array size for you. That means you should keep track of that yourself! or else you risk undefined behaviour.

There exist other data structures that can grow and shrink as required (such as linked list) but those usually use "the free store" or "heap memory" and work differently than a built in array that gets allocated on the stack.

Answer 3

When you declare an array it's impossible to access an element >= of the dimension setted. The argument setted should be constant and known in compilation-time

For example

int n;
int arr[n]; // error: this is not known in compilation-time

int arr[2];
arr[5] = 6; // error: arr[5] doesn't actually exists!