logo codesdope

Arrays in C


In simple English, an array is a 'collection of things'.

So, in C, it is a collection but of similar type of data which can be either of int, float, double, char (String), etc (cannot be a collection where some of the data are of type integer and some of are float).

Why Array


Suppose we need to store the marks of 50 students in a class and calculate the average marks. So, declaring 50 separate variables will do the job but no programmer would like to do so. And there comes array in action.

How to declare an array


datatype   array_name [ array_size ] ;

For example, take an integer array 'n'.

int n[6];

n[ ] is used to denote an array 'n'.

So, n[6] means that 'n' is an array of 6 integers. Here, 6 is the size of the array i.e. there are 6 elements of the array 'n'.

Giving array size i.e. 6 is necessary because compiler needs to allocate space to that many integers. Compiler determines the size of array by calculating the number of elements of an array.

Here 'int n[6]' will allocate space to 6 integers.

We can also declare an array by another method.

int n[ ] = { 2,3,15,8,48,13 };

In this case, we are declaring and assigning values to the array at the same time. Here, no need to specify the array size because compiler gets it from { 2,3,15,8,48,13 }.

Pictorial view of this:

element 2 3 15 8 48 13
index 0 1 2 3 4 5

0,1,2,3,4 and 5 are indices. It is like they are identity of 6 different elements of an array. Index starts from 0. So, the first element has a index of 0.

Index of an array starts with 0.

Here,
n[0] is 2
n[1] is 3
n[2] is 15
n[3] is 8
n[4] is 48
n[5] is 13

Assigning Values to Array


By writing int n[ ]={ 2,4,8 }; , we are declaring and assigning values to the array at the same time, thus initializing it.

But when we declare an array like int n[3]; , we need to assign values to it separately. Because 'int n[3];' will definitely allocate space of 3 integers in memory but there are no integers in that.

To initialize it, assign a value to each of the elements of the array.

n[0] = 2;
n[1] = 4;
n[2] = 8;

It is just like we are declaring some variables and then assigning values to them.

int x,y,z;
x=2;
y=4;
z=8;

Thus, the first way of assigning values to the elements of an array is by doing so at the time of its declaration

int n[ ]={ 2,4,8 };

and the second method is declaring the array first and then assigning values to its elements.

int n[3];

n[0] = 2;
n[1] = 4;
n[2] = 8;

You can understand this by treating n[0], n[1] and n[2] as different variables you used before.

Just like variable, array can be of any other data type also.

float f[ ]= { 1.1, 1.4, 1.5};

Here, f is an array of floats.

First, let's see the example to calculate the average of the marks of 3 students. Here, marks[0] represents the marks of the first student, marks[1] represents marks of the second and marks[2] represents marks of the third student.

#include <stdio.h>
int main()
{
    int  marks[3] ;
    float  average ;
    printf ( "Enter marks of first student\n" )   ;
    scanf ( " %d" , &marks[0] ) ;
    printf ( "Enter marks of second student\n" )   ;
    scanf ( " %d" , &marks[1] ) ;
    printf ( "Enter marks of third student\n" )   ;
    scanf ( " %d" , &marks[2] ) ;
    average = ( marks[0] + marks[1] + marks[2] ) / 3.0 ;
    printf ( "Average marks : %f\n" , average ) ;
    return 0;
}
Output
Enter marks of first student
23
Enter marks of second student
25
Enter marks of third student
30
Average marks : 26.000000

Here you just saw a working example of array, we treated array in an exactly similar way as we had treated normal variables. &marks[0], &marks[1] and &marks[2] will represent the addresses and marks[0], marks[1] and marks[2] the different values.

In the above example, two points should be kept in mind.
The average value should be of type 'float' because the average of integers can be float also.
Secondly, while taking out the average, the sum of the numbers should be divided by 3.0 and not 3, otherwise you will get the average value as an integer and not float.

We can also use for loop as done in the next example.

#include <stdio.h>
int main()
{
    int n[10]; /* declaring n as an array of 10 integers */
    int i,j;
    /* initializing elements of array n */ 
    for ( i = 0; i<10; i++ ) 
    {
        printf("Enter value of n[%d]",i);
        scanf("%d",&n[i]);
    }
    /* printing the values of elements of array */
    for (j = 0; j < 10; j++ ) 
    {
        printf("n[%d] = %d\n", j, n[j] );
    }
    return 0;
}
Output
Enter value of n[0]12
Enter value of n[1]34
Enter value of n[2]23
Enter value of n[3]78
Enter value of n[4]32
Enter value of n[5]21
Enter value of n[6]4
Enter value of n[7]23
Enter value of n[8]46
Enter value of n[9]24
n[0] = 12
n[1] = 34
n[2] = 23
n[3] = 78
n[4] = 32
n[5] = 21
n[6] = 4
n[7] = 23
n[8] = 46
n[9] = 24

The above code was just to make you familiar with loops with an array because you will be doing this many times later.
The code is simple, i and j starts from 0 because the index of an array starts from 0 and goes up to 9 ( for 10 elements ). So, i and j goes up to 9 and not 10 ( i<10 and j<10 ) . So, in the code n[i] will be n[1], n[2], ...., n[9] and things will go accordingly.

If we have declared an array with some array size and assigned values to only some elements of that array, then the values of other elements are automatically assigned zero.

Suppose we declare and initialize an array as

int n[5] = { 12, 13, 5 };

This means that n[0]=12, n[1]=13 and n[2]=5 and rest all elements are zero i.e. n[3]=0 and n[4]=0.

Similarly,

int n[5];
n[0] = 12;
n[1] = 13;
n[2] = 5;

In the above code, n[0], n[1] and n[2] are initialized to 12, 13 and 5 respectively. Therefore, n[4] and n[5] are both 0.

Array allocates contiguous memory. Thus if the address of the first element of an array of integers is 223698688 then the address of the second element will be 223698692( 223698688+4 (4 is the size of one integer) ) and third will be 223698696 and so on. This means that the memories of all elements of an array are allocated together and are continuous.

Pointer to Arrays


Till now, we have seen how to declare and initialize an array. Now, we will see how we can have pointers to arrays too. But before starting, we are assuming that you have gone through Pointers from the topic Point Me. If not, then first read the topic Pointers and practice some problems from the Practice section.

As we all know that pointer is a variable whose value is the address of some other variable i.e. if a variable y points to another variable x means that the value of the variable 'y' is the address of 'x'.

Similarly, if we say that a variable y points to an array n, it would mean that the value of 'y' is the address of the first element of the array i.e. n[0]. So, y is the pointer to array n.

Array name is a pointer to the first element of the array.

If p is a pointer to array age, means that p(or age) points to age[0].

int age[50];
int *p;
p = age;

The above code assigns p the address of the first element of age.

Now, since p points to the first element of array age, *p is the value of the first element of the array.

Since *p refers to the first array element, *(p+1) and *(p+2) refers to the second and third elements respectively and so on.

So, *p is age[0], *(p+1) is age[1], *(p+2) is age[2].

Similarly, *age is age[0] ( value at age ), *(age+1) is age[1] ( value at age+1 ), *(age+2) is age[2] ( value at age+2 ) and so on.

That's all in pointer to arrays.

Now let's see some examples.

#include <stdio.h>
int main()
{
    float n[5] = { 20.4, 30.0, 5.8, 67, 15.2 }; /* declaring n as an array of 5 floats */
    float *p; /* p as a pointer to float */
    int i;
    p = n; /* p now points to array n */
    /* printing the values of elements of array */
    for (i = 0; i < 5; i++ ) 
    {
        printf("*(p + %d) = %f\n", i, *(p + i) );/* *(p+i) means value at (p+0),(p+1)...*/
    }
    return 0;
}
Output
*(p + 0) = 20.400000
*(p + 1) = 30.000000
*(p + 2) = 5.800000
*(p + 3) = 67.000000
*(p + 4) = 15.200000

As p is pointing to the first element of array, so, *p or *(p+0) represents the value at p[0] or the value at the first element of p. Similarly, *(p+1) represents value at p[1]. And *(p+3) and *(p+4) represents p[3] and p[4] respectively. So accordingly, things were printed.

The above example sums up the above concepts. Now, let's print the address of the array and also individual elements of the array.

#include <stdio.h>
int main()
{
    int n[4] = { 20, 30, 5, 67 }; /* declaring n as an array of 4 integers */
    int *p; /*a pointer*/
    int i;
    p = n; /*p is pointing to array n*/
    /* printing the address of array */
    printf("Address of array n[4] = %u\n" , p ); /*p points to array means store the address of the first element of array*/
    /* printing the addresses of elements of array */
    for (i = 0; i < 4; i++ ) 
    {
        printf("Address of n[%d] = %u\n" , i, &n[i] );
    }
    return 0;
}
Output
Address of array n[4] = 2491554384
Address of n[0] = 2491554384
Address of n[1] = 2491554388
Address of n[2] = 2491554392
Address of n[3] = 2491554396

As you have noticed that the address of the first element of n and p are same and this means I was not lying!
You can print other elements' addresses by using (p+1), (p+2) and (p+3) also.

Let's pass whole Array in Function


In C, we can pass an element of an array or the full array as an argument to a function.

Let's first pass a single array element to function.

#include <stdio.h>
void display(int a)
{
        printf("%d\n",a);
}
int main() 
{
    int n[ ] = { 20, 30, 23, 4, 5, 2, 41, 8 }; 
    display(n[2]); 
    return 0;
}
Output
23

Passing an entire Array in a Function


We can also pass whole array to a function by passing array name as argument. Yes, the trick is that we will pass the address of an array, that is the address of the first element of the array. Thus, by having the pointer of the first element, we can get the entire array as we have done in examples above.

passing array to function

Let's see an example to understand it.

#include <stdio.h>
float average(float a[])
{
    int i;
    float avg, sum=0;
    for(i=0;i<8;++i)
    {
        sum+= a[i];
    }
    avg = sum/8;
    return avg;
}
int main() 
{
    float b, n[ ] = { 20.6, 30.8, 5.1, 67.2, 23, 2.9, 4, 8 }; 
    b = average(n); 
    printf("Average of numbers=%.2f\n",b); 
    return 0;
}
Output
Average of numbers=20.20

average(float a[]) - It is the function that is taking an array of float. And rest of the body of the function is performing accordingly.
b = average(n) - One thing you should note here is that we passed n. And as discussed earlier, n is the pointer to the first element or pointer to the array n[]. So, we have actually passed the pointer.

In the above example in which we calculated the average of the values of the elements of an array, we already knew the size of the array i.e. 8.

Suppose we are taking the size of the array from the user. In that case, the size of the array is not fixed. Here, we need to pass the size of array as the second argument to the function.

#include <stdio.h>
float average(float a[], int size)
{
    int i;
    float avg, sum=0;
    for(i=0;i<size;i++)
    {
        sum+= a[i];
    }
    avg = sum/size;
    return avg;
}
int main() 
{
    int size,j; 
    printf("Enter the size of array"); 
    scanf("%d", &size); 
    float b, n[size]; 
    for(j=0; j<size; j++) 
    { 
        printf("Value of n[%d] : ", j);
        scanf("%f", &n[j]);
    } 
    b = average(n, size); 
    printf("Average of numbers=%.2f\n",b); 
    return 0;
}
Output
Enter the size of array4
Value of n[0] : 12
Value of n[1] : 234
Value of n[2] : 12.43
Value of n[3] : 43.43
Average of numbers=75.46

The code is similar to the previous one except that we passed the size of array explicitly - float average(float a[], int size).

We can also pass an array to a function using pointers. Let's see how.

#include <stdio.h>
display(int *p)
{
    int i;
    for(i=0;i<8;++i)
    {
        printf("n[%d] = %d\n", i, *p);
        p++;
    }
}
int main() 
{
    int n[ ] = { 1, 2, 3, 4, 5, 6, 7, 8 }; 
    display(n); 
    return 0;
}
Output
n[0] = 1
n[1] = 2
n[2] = 3
n[3] = 4
n[4] = 5
n[5] = 6
n[6] = 7
n[7] = 8

In the above example, the address of the array i.e. address of n[0] is passed to the formal parameters of the function.

display(int *p) - This means that function 'display' is taking a pointer to an integer.

Now we passed the pointer of an integer i.e. pointer of the array n[] - 'n' as per the demand of our function 'display'.
Since p is the address of the array n[] in the function 'display' i.e. address of the first element of the array (n[0]), therefore *p represents the value of n[0]. In the for loop in function, p++ increases the value of p by 1. So, when i=0, the value of *p gets printed. Then p++ increases *p to *(p+1) and in the second loop, the value of *(p+1) i.e. n[1] also gets printed. This loop continues till i=7 when the value of *(p+7) i.e. n[7] gets printed.

passing array to function

2 D Arrays


What if arrays are 2 dimensional?

Yes, 2-dimensional arrays also exist and are generally known as matrix. These consist of rows and columns.

Before going into its application, let's first see how to declare and initialize a 2 D array.

Declaration of 2 D Array

Similar to one-dimensional array, we define a 2-dimensional array as below.

int a[2][4];

Here, a is a 2-D array of type int which consists of 2 rows and 4 columns.

It is like

Column 0 Column 1 Column 2 Column 3
Row 0 a[0][0] a[0][1] a[0][2] a[0][3]
Row 1 a[1][0] a[1][1] a[1][2] a[1][3]

Now let's see how to initialize a 2-dimensional array.

Assigning Values to a 2 D Array


Same as in one-dimensional array, we can assign values to the elements of a 2-dimensional array in 2 ways as well.

In the first method, just assign a value to the elements of the array. If no value is assigned to any element, then its value is assumed to be zero.

Suppose we declared a 2-dimensional array a[2][2]. Now, we need to assign values to its elements.

int a[2][2];
a[0][0]=1;
a[0][1]=2;
a[1][0]=3;
a[1][1]=4;

The second way is to declare and assign values at the same time as we did in one-dimensional array.

int a[2][3] = { 1, 2, 3, 4, 5, 6 };

Here, value of a[0][0] is 1, a[0][1] is 2, a[0][2] is 3, a[1][0] is 4, a[1][1] is 5 and a[1][2] is 6.

We can also write the above code as:

int a[2][3] = {
      {1, 2, 3},
      {4, 5, 6 }
    };

While assigning values to an array at the time of declaration, there is no need to give dimensions in one dimensional array, but in 2 D array, we need to give at least the second dimension.

Let's consider different cases of assigning values to an array at the time of declaration.

int a[2][2] = { 1, 2, 3, 4 }; /* valid */
int a[ ][2] = { 1, 2, 3, 4 }; /* valid */
int a[2][ ] = { 1, 2, 3, 4 }; /* invalid */
int a[ ][ ] = { 1, 2, 3, 4 }; /* invalid */

Why use of 2 D Array


Suppose we have 3 students each studying 2 subjects (subject 1 and subject 2 )and we have to display the marks in both the subjects of the 3 students. Let's input the marks from the user.

#include <stdio.h>
int main()
{
    float marks[3][2]; 
    int i,j; 
    for( i=0; i<3; i++) 
    { 
        /* input of marks from the user */
        printf("Enter marks of student %d\n", (i+1) );
        for( j=0; j<2; j++)
        {
            printf("Subject %d\n", (j+1) );
            scanf("%f", &marks[i][j]);
        }
    } 
    /* printing the marks of students */
    for( i=0; i<3; i++) 
    { 
        printf("Marks of student %d\n", (i+1) );
        for( j=0; j<2; j++)
        {
            printf("Subject %d : %f\n", (j+1), marks[i][j] );
        }
    }
    return 0; 
}
Output
Enter marks of student 1
Subject 1
78
Subject 2
67
Enter marks of student 2
Subject 1
79
Subject 2
87
Enter marks of student 3
Subject 1
90
Subject 2
89
Marks of student 1
Subject 1 : 78.000000
Subject 2 : 67.000000
Marks of student 2
Subject 1 : 79.000000
Subject 2 : 87.000000
Marks of student 3
Subject 1 : 90.000000
Subject 2 : 89.000000

This is something like

Subject 1 Subject 2
Student 1 78 67
Student 2 79 87
Student 3 90 89

Programming is a skill best acquired by practice and example rather than from books.
-Alan Turing

Download Our App.
BlogsDope App
Get it on Google Play
Doubt? Ask question
Close

Welcome.please sign up.

Close

Welcome.please login.