Go4Expert

Go4Expert (http://www.go4expert.com/)
-   C++ (http://www.go4expert.com/articles/cpp-tutorials/)
-   -   All about Arrays in C/C++ - Part I (http://www.go4expert.com/articles/arrays-c-cpp-part-i-t19931/)

Mridula 31Oct2009 18:38

All about Arrays in C/C++ - Part I
 

Introduction



This article tries to cover all about Arrays like from it's definition till it's usage using a single dimension.

Background



Definition

An array is a built-in Data Structure that holds a sequence of variables of same data type, that are stored in a contiguous memory locations.

Some characteristics about Arrays
  • The elements of an array are indiced and accessed by their index, where as first position/index of an array starts from "0" and last position is sizeOfArray-1 !!
  • By default, Arrays are not initialised.
  • Like any other variable, an array must be declared before it is used.
  • Each element in an Array must be printed individually.
  • An Array cannot be copied/assigned/compared from another Array directly, these operations have to be done element by element basis.
  • Name of the Array is nothing but address of/pointer to the first element of the Array
  • There is no Array bound checking done in C. Trying to access the position at sizeofArray or beyond that is an Error and results in an undefined behaviour.
  • ArrayName indicates the base address or address of the first element in the Array.
  • Address of any element in a Single Dimensional Array can be caclulated as
    ElementAddress = BaseAddress+ indexOfTheElement * SizeOfTheElement

Declaration of an Array

Declaration of an array takes data_type of the elements to be stored, variable name followed by the size of the array wrapped within square brackets as below:

data_type variableNameOfArray[no_elements]

For Example:

int employee[5] = {10,20,30,40,50};

http://www.go4expert.com/images/arti...s/empArray.JPG

where employee is the name of a single dimensional array variable, that can hold 5 variables of integer type. So, the number 5 indicates the size of the array employee.
Where "0", "1", "2", "3", "4" shows the indices of the array employee. Any element of an Array, can be accessed by using it's respective index inside [] as below:

printf("%d", employee[2]);

This will access and print the 3rd element i.e. 30 of the Array employee.


Array Initialization

We can Initilize an Array when it is declared. Initializers are constant values/expressions seperated by a comma and enclosed within flower braces {} as below:

dataType variableNameOfArray[no_elements] = {values}


int employee[5] = {120, 121, 122, 123, 124};

As a convinience, if you leave out the size of the array, it creates it with the exact size to hold that number of initial values.


int employee[] = {120, 121, 122, 123, 124};

The elements in the aggregate that are not given initilizers are default initialized according to their data type.

The code



Code: Cpp

#include<iostream.h>

int main()
{
  int array[5]={1,2};
  unsigned i;

  cout<<"\nInitilization of rest of the elements\n";
  for(i=0; i<5; ++i)
  {
    cout<<"Array["<<i<<"]"<<array[i]<<endl;
  }
}

Output:
Initilization of rest of the elements
Array[0]1
Array[1]2
Array[2]0
Array[3]0
Array[4]0


In this code, only the array index 0 and 1 are initilized with values 1 & 2, whereas rest of the elements in the array will be initilized with zeros.

Also, We can initialize all the elements of an integer Array with 0 value by assigning with empty {} as below:

int array[5] = {};


Array Initilization in a class

Arrays are always initilized outside the class. Usually static const data types are initilized inside the class declaration, but, static const Arrays are also initilized outside the class declaration as below:

The code



Code: Cpp

#include<iostream.h>

class Abc{
  static const int arr[3];
  static const double var = 3.14;

  public: Abc()
          {
            for(int i=0; i<3; ++i)
            {
              printf("%d", arr[i]);
            }
          }
};

const int Abc::arr[3] = {1,2,3};

int main()
{
  Abc aa;

  return(0);
}

Output
123



Size of an Array

Irrespective of whether an Array is initialized or not, the size of an Array is nothing but ;
sizeOf(dataType of the element) * arraySize.

The code



Code: Cpp

#include<iostream.h>

int main()
{
  int arr[5];

  cout<<"\nBy default array elements are not initilized\n";
  for(int i=0; i<5; ++i)
  {
    cout<<"arr["<<i<<"]="<<arr[i]<<endl;
  }
  cout<<endl;
 
  cout<<"Size of this array \"arr\" is: "<<sizeof(arr)<<endl;
 
  return(0);
}

Output:
By default array elements are not initilized
arr[0]=-4265576
arr[1]=163864
arr[2]=3
arr[3]=-4265476
arr[4]=4

Size of this array "arr" is: 20


The above code also confirms that by default array elements are not initilized.


Arrays and References

We cannot have an Array of references. Whereas we can have an Reference to an Array as an argument to a function.

The code



Code: Cpp

#include<iostream.h>

void print(int (&arr)[3])
{
  for(int i=0; i<3; ++i)
  {
    cout<<arr[i]<<endl;
  }
}

int main()
{
  int array[3]={1,2,3};
  print(array);

  return(0);
}

Output:
1
2
3



Pointer Arithmetic and Arrays

Address to a first element of an Array is nothing but Array name itself and it is a pointer of it's element type or Array type. Adding 1 to this pointer, gives the address of the next element in the Array. It means, it adds with 1*sizeOf(elementDataType) to the base address of the array.

For Example:

Code: Cpp

int array[3] = {10,20,30};
cout<<"*(array+1)"<<*(array+1)<<endl;


Results the content of second element i.e. "20". array+1 adds (1*4) to the base address i.e. array and gives the content of that address. Where 4 is size of an int nothing but size of an element of array here!!

In other way we can say

array or array+0 ----> &array[0]

*array -----> array[0]


And

array+1 ------> &array[1]
*(array+1) -----> array[1]

.
.
.

array+i --------> & array[i]
*(array+i) ------> array[i]


Same way, we can as well do subtraction here.

By seeing these examples, we can say that array behaves like a pointer, but really it is not. As we cannot assign values to it as below:

Code: Cpp

int arr[5];
int j;
arr = &j // gives complation error!!
 


But however we can assign an array name to a pointer as below:

Code: Cpp

int arr[5];
int *p = arr; or
p = &arr[0]



Static and Dynamic Array allocation

int employee[5];

When an Array is declared like above, the memory is allocated for all the elements of it and it will be there till the life time of the program. This is called as Static Array allocation. So, here the developer knows in advance the size of the Array at compile time itself.

In case, if the developer does not know the Array size at compile time, then Array can be alllocaed at run time as well. This is called as Dynamic Allocation of an Array.

For Example:

The code



Code: Cpp

#include<iostream.h>

int main()
{
  int *arr;
  int size, i;
 
  cout<<"\nEnter the Array size:\n";
  cin>>size;

  cout<<"\nEnter Array elements\n";
  for(i=0; i<size; ++i)
  {
    cin>>arr[i];
  }

  cout<<"\nPrinting the Array elements\n";
  for(i=0; i<size; ++i)
  {
    cout<<"arr["<<i<<"]="<<arr[i]<<endl;
  }

  return(0);
}

Output:

./a.out

Enter the Array size:
3

Enter Array elements
20
30
40

Printing the Array elements
arr[0]=20
arr[1]=30
arr[2]=40



Arrays of Characters

Arrays of characters are special, as we can Initialize the Array using string literals as below:

char array[8]= {'M', 'r', 'i', 'd', 'u', 'l', 'a'}
char array[8]= "Mridula";


Here we can see that Mridula can be Initized as a string !!

Also, if some of the elements in character Arrays are not given initizers, then they will be initilized with NULL or '\0' character.As like initeger Arrays, character arrays are also can be initilized with NULL character just by assigning them with {} as below.

char array[8] = {};

Otherwise, by Default, it will be initilized with some junk characters.


Array as an Argument to a function

A function can receive Array as an argument with any of the below forms:
  1. As a pointer to an Array like int func(int *array);
  2. As a sized Array like int func(int array[3]);
  3. As an unsized Array like int func( int array[]);
  4. As a reference to an Array like void func(int (&arr)[3]);

But always an array name that as a function argument is converted to a pointer to the start of array, at compile time itself, by the compiler. So any reference to that array inside the function is treated as a pointer reference.

For Example:

Code: Cpp

int array1[50];

void fun(int arr2[])
{
  arr2[1] = 3;
  *arr2 = 3;
  arr2 = array1;
 
}


int main()
{
int arr2[3];

arr2[1] = 3;
*arr2 = 3;

//we cannot do the below
//arr2 = array1;

return(0);
}


If we see the above code snippets, array when it is passed as an argument to a function, can be assigned to another array as it is treated always as a pointer. Whereas we cannot do the same in main function, it would give compilation error, as we are trying to change the array name itself, which cannot be done.

Also

Code: Cpp

void func(int [] a)
{
 return sizeof (a); // returns the size of the pointer p not the size of the array !!
}

int main()
{
 int num[2];
 cout << sizeof (num); //Returns the size of the array num!!
 func(num);
}


The above code snippet confirms that array which is passed to as an argument to function, is treated as a pointer inside the function as the sizeof that argument results with sizeof a pointer and not sizeof the Array.

Also, by giving/sending a pointer to any intermediate element of an Array to a function, we can just pass the slice/last part of the array from that intermediate point.

For Example:

The code



Code: Cpp

#include<iostream.h>

void func(int *arr)
{
  int i;
 
  for (i=0; i<2; ++i)
  {
    cout<<arr[i]<<endl;
  }
}

int main()
{
  int array[4] = {100,200,300,400};
  cout<<"Sending slice of an array...\n";

  int * ptr = &array[2];
  func(ptr);
 
  return(0);
}
Output:

./a.out
Sending slice of an array...
300
400


Here ptr which is pointing to 2nd index of the array[4] is sent to func and so only 2nd and 3rd indices has been printed on accessing the array through ptr in function func.


Operations Done on Arrays
  • Storing/Collecting elements of same data type.
  • Iterating through all the elements in an Array
  • Searching an element in an Array
  • Comparision of two Arrays
  • Assignment operation

The bottom line: Arrays are nothing but collection of elements of same Data Type, having same identifer as Array name itself !!.

Karpov2007 1Nov2009 01:50

Re: All about Arrays in C/C++ - Part I
 
Stop use int in examples of array indexing! :-)
See: About size_t and ptrdiff_t

shabbir 1Nov2009 19:49

Re: All about Arrays in C/C++ - Part I
 
Nominate this article for Article of the month - Oct 2009

shabbir 17Nov2009 09:27

Re: All about Arrays in C/C++ - Part I
 
Start voting for this article for Article of the month - Oct 2009

rasd123 13Dec2009 05:42

Re: All about Arrays in C/C++ - Part I
 
Thanks to share this information.

technica 18Dec2009 12:32

Re: All about Arrays in C/C++ - Part I
 
Both your articles Part I and Part II on this topic are real good. They will surly help lot looking for help and understanding arrays.

Mridula 18Dec2009 13:55

Re: All about Arrays in C/C++ - Part I
 
many thanks!!

rasd123 20Dec2009 05:38

Re: All about Arrays in C/C++ - Part I
 
Thankiossk Cool!

sathi 20Dec2009 19:52

Re: All about Arrays in C/C++ - Part I
 
its amazing ,but i don't understanding about arrays. i'am begineer..how can i easily understand about arrays..reply must anybody..i'am very curiosity know about c++..


All times are GMT +5.5. The time now is 11:44.