Difference Between Array and Pointer

There is a close relationship between array and pointer. The pointer can be used to access the array elements, accessing the whole array using pointer arithmetic, makes the accessing faster. There is a basic difference between a pointer and an array that is, an array is a collection of variables of similar data type whereas the pointer is a variable that stores the address of another variable. There are some other differences between an array and a pointer which are discussed below in the comparison chart.

Content: Array Vs Pointer

1. Comparison Chart
2. Definition
3. Key Differences
4. Conclusion

Comparison Chart

Basis for Comparison	Array	Pointer
Declaration	//In C++ type var_name[size]; //In Java. type var-name[ ]; var_name = new type[size];	//In C++ type * var_name;
Working	Stores the value of the variable of homogeneous datatype.	Store the address of the another variable of same datatype as the pointer variable's datatype.
Generation	An array of pointers can be generated.	A pointer to an array can be generated.
Java Support	Support the concept of array.	Does not support pointers.
Storage	A normal array stores values of variable and pointer array stores the address of variables.	Pointers are specially designed to store the address of variables.
Capacity	An array can store the number of elements, mentioned in the size of array variable.	A pointer variable can store the address of only one variable at a time.

Definition of Array

An array is the collection of the elements of the same datatype, and all these elements are referred by a common name, which is the name of an array variable. A particular array element can be accessed by accessing the specific index of that array where that element is stored.Arrays can be a one-dimensional array, a two-dimensional array, or multidimensional array. An array of pointers can also be generated i.e. an array containing all variable as pointer variable. In ‘C++’ the arrays are statically allocated whereas, in ‘Java’ the arrays are dynamically allocated.

// In C++
type var_name[size];
//In Java.
type var-name[ ];
var_name = new type[size];

Here the ‘type’ denotes the data type of an array variable, ‘var_name’ denotes the name given to the array variable, ‘size’ denote the capacity of array variable i.e. how many elements of ‘type’  can be stored in that array variable. There are two methods of accessing an array, first ‘pointer arithmetic’ and second ‘array indexing’, of which ‘pointer arithmetic’ is faster.

//accessing using pointer arithmetic
Void display_array(int * S){
while (*s){
cout(<< "value is"<<*s);
*s++;
}
}

Using ‘pointer arithmetic’ would work faster as compared to ‘array indexing’, i.e. accessing array variable using its index. If you need to pass an array of pointers into a function, it can be done by using the same method you use to pass a normal array i.e. directly call the function with the name of the array, without any index.

Let us understand it with the example

//Declaring the array of pointers.
int *p[10];

Here, it shows that ‘p’ is an array of integer type, it will hold the address of 10 variable of integer type. Let us pass the above pointer array into a function display( ).

display( p);  //Call the function display.

void display(int *d[]){  //Function receving the pointer array.
for(int i=0; i<10; i++){
cout<<( "index"<<i);
cout(<<"value at the address stored at this index"<<*p[i]);
}
}

This function will display the values, present in the variables, whose addresses are stored in this pointer array sequentially.

Definition of Pointer

The pointer is a variable that holds the memory address of another variable. The datatype of both, the pointer variable and the variable whose address is being assigned to a pointer variable, must be same. The pointer variable is as declared as follow.

//Declaration in C++
type * name;

Here, ‘type’ is a datatype, ‘name’ is the name of the pointer variable. The ‘type’ define what kind of variable’s address can be stored in the pointer variable. For example, the integer pointer will store the address of integer variable. There are two pointer operators ‘*’ and ‘&’. The operator ‘*’  returns the value located at the address, which is stored in the variable followed by the ‘*’ sign. The ‘&’ operator returns the address of the variable followed by ‘&’ sign.

//for example
int b=10
int a= &b;
//Here the address of 'b' is stored in the variable 'a'.
//let's the address of 'b' is 2000, so now 'a=2000'.
int c=*a;
//Here, the integer pointer variable '*a' will return the value which is located at the address stored in 'a' .ie. 'c=10'.

There are only two arithmetic operators you can use on pointers i.e. addition and subtraction. If you apply increment on an integer pointer variable, it will be incremented by the size of datatype i.e. by 2 bytes, as it is an integer pointer, on increment it will have to point next integer variable. Same is the case with decrement.

// 'p' is a integer pointer containg value 2000.
p++;
// now 'p=2002'.
p--;
//now 'p' again contain 2000 as decremented by two bytes.

Note:

Java does not support or strictly avoid pointers.

Conclusion:

When we need to work on data elements of similar data type then, instead of working separately on variables, we can create an array of those variables of similar data types and then operate on it. Pointers are necessary for some program, it gives tremendous power, but unfortunately, if a pointer contains  an incorrect value, it will be the most difficult bug to find.