C++  Foundation  with  Data  Structures  

Lecture  6  :  Arrays  
 

 
  

 
What  are  arrays?  
 

In  cases  where  there  is  a  need  to  use  several  variables  of  same  type,  for  storing,  
example,   names   or   marks   of   ‘n’   students   we   use   a   data   structure   called   arrays.  
Arrays  are  basically  collection  of  elements  having  same  name  and  same  data  type.  
Using   arrays,   saves   us   from   the   time   and   effort   required   to   declare   each   of   the  
element  of  array  individually.  

Creating  an  array  

 

The  syntax  for  declaring  an  array  is:  

Data_type    array_name  [  array_size  ]  ;  
Example  :  
float  marks[5];  
Here,  we  declared  an  array,  marks,  of  floating-­‐point  type  and  size  5.  Meaning,  it  
can  hold  5  floating-­‐point  values.  
Similarly,  we  can  declare  array  of  type  int  as  follows:  
int  age[10];  

How  are  arrays  stored?    

 

The  elements  of  arrays  are  stored  contiguously,  i.e.,  at  consecutive  memory  
locations.  The  name  of  the  array  actually  has  the  address  of  the  first  element  of  
the  array.  Hence  making  it  possible  to  access  any  element  of  the  array  using  the  
starting  address.    
Example:    
 int  age[  ]  =  {10,  14,  16,  18,  19};  

 
  

Suppose  the  starting  address  of  an  array  is  1000,then  address  of  second  and  third  
element  of  array  will  be  1004,  1008  respectively  and  so  on.  
10   14   16   18   119  
                   1000                                                      1004                                                1008                                                  1012                                                1016  

 
Accessing  elements  of  an  array    

An  element  of  array  could  be  accessed  using  indices.  Index  of  an  array  starts  from  
0  to  n-­‐1,  where  n  is  the  size  of  the  array.  
 Syntax  for  accessing  array  element  is  :  
   Array_name[index]  

 Suppose  we  declare  array  age  of  size  5.  

int  age[10];  
age[2]  =  4                //    stores  value  4  at  index  2  
        4          
age[0]                                  age[1]                                                age[2]                                          age[3]                                          age[4]  
   

Here  the  first  element  is  age[0],  second  element  is  age[1]  and  so  on.  

 
Default  values    
Arrays   must   always   be   initialized.   If   the   array   is   not   initialized   the   respective  
memory   locations   will   contain   garbage   by   default.   Hence,   any   operation   on  
uninitialized  array  will  lead  to  unexpected  results.  

Initializing  array  at  the  time  of  declaration  

Elements   in   an   array   can   be   explicitly   initialized   to   specific   values   when   it   is  
declared,  by  enclosing  those  initial  values  in  curly  braces  {}.  
Example  
   

 
  

int  age[5]  =  {5,  2,  10,  4,  12};  

Alternatively,  
int  age[  ]  =  {5,  2,  10,  4,  12};  
5   2   10   4   12  
                   age[0]                                            age[1]                                              age[2]                                            age[3]                                            age[4]  
   

If  array  is  initialized  like  this  -­‐    

int  age[10]  =  {5,  2,  10,  4,  12};  
Then,  in  memory  an  integer  array  of  size  10  will  be  declared.  That  is,  a  continuous  
memory  block  of  40  bytes  (to  hold  10  integers)  will  be  allocated.  And  first  5  values  
of  age  are  provided,  rest  will  be  0.  
Here,    
age[0]  is  equal  to  5  
age[1]  is  equal  to  2  
age[2]  is  equal  to  10  
age[3]  is  equal  to  4  
age[4]  is  equal  to  12  
And  age[5]  to  age[9]  is  equal  to  0.  

sizeof  operator  

sizeof  is  an  operator  used  to  determine  the  length  of  the  array,  i.e.,  the  number  
of  elements  in  the  array  .  
 Example:  

 int  main(  ){  

int  myArray[  ]  =  {5,  4,  3,  2,  1};  
int  size  =  sizeof(myArray);  
cout  <<  size;  

 
  

return  0;  
}  
 Output  :  
5  
   

Passing  arrays  to  a  function    

 

Arrays  can  be  passed  to  a  function  as  an  argument.  When  an  array  is  passed  as  an  
argument,  only  the  starting  address  of  the  array  gets  passed  to  the  function  as  an  
argument.  Since,  only  the  starting  address  gets  passed  to  the  function  as  opposed  
to  whole  array,  the  size  of  the  array  cannot  be  determined  in  function  using  sizeof  
operator.   Hence,   the   arrays   that   are   passed   as   an   argument   to   a   function   must  
always  be  accompanied  by  its  size  as  another  argument.  
 Syntax  of  the  function  call  to  pass  an  array  :    
                                                             function_name(array_name,  array_size);  
 
Syntax  of  the  function  definition  that  takes  array  as  an  argument  :  
return_type  function_name(data_type  array_name,  int  size,  <other  
arguments>){  
//function  body  
}    
NOTE  :  Square  brackets  ‘[  ]’    are  not  used  at  the  time  of  function  call.  
   
Example:  
#include  <iostream>  
using  namespace  std  

 
  

   
void  printAge(int  age[  ],  int  n){  
for(int  i=0  ;  i  <  n  ;  i++){  
cout  <<  age[i]  <<  endl;  
}  
}  
int  main(){  
int  age[5]  =  {11,  14,  15,  18,  20};  
printAge(age,  5);  
return  0;  
}  
   
Output:  
11    
14  
15  
18  
20