In C programming, an array is a collection of elements of the same data type, stored in contiguous memory locations. Arrays in C programming efficiently store and manipulate multiple values of the same type, accessing each element through its index, which represents its position in the array.

The general syntax for declaring an array in C is as follows:


data_type array_name[size];

Here’s, how it works?

  • data_type: Specifies the type of elements that the array will hold (e.g., int, float, char, etc.).
  • array_name: The identifier used to access elements of the array.
  • size: The number of elements the array can hold. It must be a positive integer constant.

For example, to declare an array of integers with a size of 5:

For Instance: 

int numbers[5]; 
// This creates an integer array with 5 elements.

Arrays in C have a zero-indexed structure, implying that the index of the first element is 0, the second element’s index is 1, and so on.
To access elements of the array, you use the array name followed by the index in square brackets:

numbers[0] = 10; 
// Assigning the value 10 to the first element of the array.
numbers[1] = 20; 
// Assigning the value 20 to the second element of the array.

You can also initialize an array at the time of declaration:

int numbers[5] = {10, 20, 30, 40, 50}; 
// Initializing the array with specific values.


If you don’t provide enough values during initialization, the remaining elements are automatically initialized to 0 (for numeric types) or ‘\0’ (for char arrays).

C also supports multi-dimensional arrays, which are arrays of arrays. For example, a 2D array can declare like this:

int matrix[3][3]; 
// This creates a 2D integer array with 3 rows and 3 columns.


Working with arrays in C typically involves loops (e.g., for loop) to iterate through the elements and perform operations on them efficiently.

Keep in mind that C does not provide built-in bounds checking for arrays, so it’s essential to ensure you don’t access elements outside the valid index range to avoid undefined behavior and potential bugs in your program.

Types Of Arrays

In C programming, there are different types of arrays based on their dimension and usage. The most common types of arrays are:

One-Dimensional Array:

  • A one-dimensional array is the simplest form of an array that stores elements in a linear sequence.
  • Each element is accessed using a single index.
  • Syntax: data_type array_name[size];

For Instance: 

int numbers[5]; 
// One-dimensional array of integers with 5 elements.


Two-Dimensional Array:

  • A two-dimensional array is an array of arrays, organized in a grid or matrix.
  • Elements are accessed using two indices: one for the row and one for the column.
  • Syntax: data_type array_name[rows][columns];

For Instance: 

int matrix[3][3]; 
// Two-dimensional array of integers with 3 rows and 3 columns.


Multi-Dimensional Array:

  • C allows you to create arrays with more than two dimensions, commonly known as multi-dimensional arrays.
  • Elements are accessed using multiple indices corresponding to the array’s dimensions.
  • Syntax: data_type array_name[size1][size2]…[sizeN];

For Instance: 

float data[2][3][4];
/*A three-dimensional array of floating-point 
 numbers with dimensions 2x3x4.*/


Multi-dimensional arrays are more versatile and allow for the creation of complex data structures, such as matrices, tables, and grids. Working with arrays in C programming is fundamental because they play a vital role in various data manipulation and algorithmic tasks.

In the next tutorial, you will learn more about multidimensional arrays (array of an array).