Array size redefinition

Question

So basically according to definition of array we cannot change array size. But if I am adding element to a same array by shifting other elements to the right of array, so the array size is going to increase.

How this is possible?

#include<stdio.h>

int main() {
  int n, j, k, item;
  printf("Enter size of array:\n");
  scanf("%d", &n);
  printf("Enter element to insert and position of element:\n");
  scanf("%d,%d", &item, &k);
  int a[n];
  for (j = 0; j < n; j++) {
    printf("Enter a[%d] element:\n", j);
    scanf("%d", &a[j]);
  }
  j = n - 1;
  while (j >= k - 1) {
    a[j + 1] = a[j];
    j = j - 1;
  }
  a[k - 1] = item;
  for (j = 0; j <= n; j++) {
    printf("%d\n", a[j]);

  }
}

Answer 1

Shifting the contents of the array to the right will not resize the array. If the array was not already large enough to hold the result of the shift, then you have overrun the array object, and have induced undefined behavior.

There is no way to dynamically increase the size of a variable with static or auto duration (e.g., global or local variables), and this includes arrays. If your compiler supports variable length arrays (VLAs), changing the value of the expression controlling the dimension of the array does not affect the array's size.

int main (void) {
    int n = 3;
    int v[n];
    printf("%zu\n", sizeof(v));
    ++n;
    printf("%zu\n", sizeof(v));
}

The program above will print the same value twice.

Answer 2

I am not entirely sure what you're asking, but for any readers interested in knowing how to dynamically change the size of an array in C: if an array is declared in stack memory, its size cannot change. However, a block of memory intended to be used as an array is declared on the heap (i.e. with malloc or calloc), can be reallocated with a different size if necessary:

int *data = malloc(10 * sizeof(int)), *data2 = NULL;
int i;
if(data == NULL)
{
     perror("malloc");
     exit(EXIT_FAILURE);
}
for (i = 0; i < 10; i++)
{
    data[i] = i;
}

data2 = realloc(data, 11 * sizeof(int));
if(data2 == NULL)
{
     free(data);
     perror("realloc");
     exit(EXIT_FAILURE);
}
else 
{ 
    data = data2; 
}
data[10] = 10;

for (i = 0; i < 11; i++)
    printf("%d ", data[i]);

free(data);
data = NULL;

Shifting elements in an array down one element will not change its size.

Answer 3

If you declare an array as

T a[N]; // assume N is a constant expression

then a can only ever hold N elements of type T - no more, no less. You cannot add extra elements to the array, nor can you remove elements from the array.

However...

C does not force any bounds checking on array subscripting, so it's possible that you can read or write past the end of the array such as

a[N + 2] = x;

The behavior on doing so is undefined - your program may work as expected, or it may crash immediately, or you may corrupt other objects in the program. The runtime environment will (most likely) not throw an IndexOutOfBounds-type exception.

There is a thing called a variable-length array that was added in C99, where the array size is not a constant expression:

size_t size = some_value();
T a[size];

Variable length arrays are only variable length in the sense that their size isn't determined until runtime - however, once defined, their size is fixed throughout their lifetime, and like regular arrays, they cannot grow as new items are added.

If you dynamically allocate a chunk of memory using

T *a = malloc( sizeof *a * some_size );

then you can grow or shrink that chunk of memory using realloc:

T *tmp = realloc( a, sizeof *a * (some_size * 2) ); 
if ( tmp )
{
  a = tmp;
  some_size *= 2;
}

Answer 4

.... array we cannot change .. But if I (do something special) ... the array size is going to increase.

How this is possible?

Undefined behavior

Arrays cannot change size once defined.

Code attempts to assign a[j + 1] with j = n-1 and that is a[n]. This is outside array a[] and so undefined behavior. Rest of code is irrelevant for at that point anything is possible, code crash, error report, even apparent successful array expansion, etc.

  int a[n];
  ...
  j = n - 1;
  while (j >= k - 1) {
    a[j + 1] = a[j]; // To attempt access to `a[n]` is UB