Variable Length Arrays in C: Dynamic Memory Allocation

Learn about variable length arrays (VLAs) in C, a powerful feature that allows you to dynamically allocate array sizes based on runtime conditions. Understand how to declare and use VLAs effectively, and explore their applications in creating flexible and efficient C programs.

Variable Length Arrays in C

A variable length array in C is also called a variable-sized or runtime-sized array. It is an array whose length is determined at runtime rather than at compile time. Its size depends on a value generated during the runtime of a program, usually received as an input from the user.

Usually, the array size is declared beforehand in the program as follows:

Code


int arr[10];

The size of an array, once declared, remains fixed during the execution of a program and cannot be changed during its runtime. However, in the case of a Variable Length Array (VLA), the compiler allocates the memory with automatic storage duration on the stack. The support for VLAs was added in the C99 standard.

Creating a Variable Length Array

The syntax for creating a variable length array is as follows:

Syntax


void arr_init(int length) {
   int arr[length];
   // code using arr
}

Example

The following example demonstrates how you can create a variable length array:

Code


#include 

int main() {
   int i, j;
   int size; // variable to hold size of one-dimensional array

   printf("Enter the size of one-dimensional array: ");
   scanf("%d", &size);

   int arr[size];
   
   for(i = 0; i < size; ++i) {
      printf("Enter a number: ");
      scanf("%d", &j);
      arr[i] = j;
   }

   for(i = 0; i < size; ++i)
      printf("a[%d]: %d\n", i, arr[i]);

   return 0;
}

Output


Enter the size of one-dimensional array: 5
Enter a number: 1
Enter a number: 5
Enter a number: 7
Enter a number: 8
Enter a number: 7

a[0]: 1
a[1]: 5
a[2]: 7
a[3]: 8
a[4]: 7

Two-dimensional Variable Length Arrays

We can also declare and use a two-dimensional variable length array.

Example 1

Take a look at the following example:

Code


#include 

int main() {
   int i, j, x;
   int row, col; // number of rows & columns of 2-D array

   printf("Enter number of rows & columns of 2-D array:\n");
   scanf("%d %d", &row, &col);

   int arr2D[row][col];
   for(i = 0; i < row; ++i) {
      for(j = 0; j < col; ++j) {
         printf("Enter a number: ");
         scanf("%d", &x);
         arr2D[i][j] = x;
      }
   }

   for(i = 0; i < row; ++i) {
      printf("\n");
      for(j = 0; j < col; ++j)
         printf("%d\t", arr2D[i][j]);
   }

   return 0;
}

Output


Enter number of rows & columns of 2-D array:
2
3
Enter a number: 10
Enter a number: 20
Enter a number: 30
Enter a number: 40
Enter a number: 50
Enter a number: 60
10	20	30	
40	50	60

Example 2

The following code declares a variable length one-dimensional array and populates it with incrementing numbers:

Code


#include 

int main() {
   int n;
    
   printf("Enter the size of the array: \n");
   scanf("%d", &n);
    
   int arr[n];
    
   for(int i = 0; i < n; i++)
      arr[i] = i+1;
    
   printf("The array elements are: ");

   for(int i = 0; i < n; i++)
      printf("%d ", arr[i]);
    
   return 0;
}

Output


Enter the size of the array: 
5
The array elements are: 1 2 3 4 5

Example 3

The following code fills the variable length array with randomly generated numbers using the functions srand() and rand() from the stdlib.h header file:

Code


#include 
#include 
#include 

void oneDArray(int length, int a[length]); // function prototype
void twoDArray(int row, int col, int a[row][col]); // function prototype

int main() {
   int i, j; // counter variable
   int size; // variable to hold size of one-dimensional array
   int row, col; // number of rows & columns of two D array
   srand(time(NULL));
   
   printf("Enter the size of one-dimensional array: ");
   scanf("%d", &size);
   
   printf("Enter the number of rows & columns of 2-D array:\n");
   scanf("%d %d", &row, &col);

   // declaring arrays
   int arr[size]; // one-dimensional array
   int arr2D[row][col]; // 2-D array

   // one-dimensional array
   for(i = 0; i < size; ++i) {
      arr[i] = rand() % 100 + 1;
   }

   // two-dimensional array
   for(i = 0; i < row; ++i) {
      for(j = 0; j < col; ++j) {
         arr2D[i][j] = rand() % 100 + 1;
      }
   }

   // printing arrays
   printf("One-dimensional array:\n");
   for(i = 0; i < size; ++i)
      printf("a[%d]: %d\n", i, arr[i]);
   
   printf("\nTwo-dimensional array:\n");
   for(i = 0; i < row; ++i) {
      printf("\n");
      for(j = 0; j < col; ++j)
         printf("%5d", arr2D[i][j]);
   }

   return 0;
}

Output


Enter the size of one-dimensional array: 5
Enter the number of rows & columns of 2-D array:
4 4
One-dimensional array:
a[0]: 95
a[1]: 93
a[2]: 4
a[3]: 52
a[4]: 68

Two-dimensional array:
   92   19   79   23
   56   21   44   98
    8   22   89   54
   93    1   63   38

Jagged Array

A jagged array is a collection of two or more arrays of similar data types of variable length. In C, the concept of a jagged array is implemented with the help of pointers of arrays.

A jagged array is represented by the following figure:

Example

In this program, we declare three one-dimensional arrays of different sizes and store their pointers in an array of pointers that act as a jagged array:

Code


#include 

int main() {
   int a[] = {1, 2};
   int b[] = {3, 4, 5};
   int c[] = {6, 7, 8, 9};
   
   int l1 = sizeof(a)/sizeof(int), 
       l2 = sizeof(b)/sizeof(int), 
       l3 = sizeof(c)/sizeof(int);
   
   int *arr[] = {a, b, c};
   int size[] = {l1, l2, l3};
   int *ptr;
   int i, j, k = 0;

   for(i = 0; i < 3; i++) {
      ptr = arr[i];
      for(j = 0; j < size[k]; j++) {
         printf("%d\t", *ptr);
         ptr++;
      }
      printf("\n");
      k++;
   }
   
   return 0;
}

Output


1       2
3       4       5
6       7       8       9