What is the difference between array of pointers and pointer to an array?

Answer 1

An array of pointers is that for eg if we have array of 10 int pointers ie int *a[10] then each element that which is stored in array are pointed by pointers. here we will have ten pointers. In pointer to an array for eg int(*a)[10] here all the elements that is all the ten elements are pointed by a single pointer.

Answer 2

There is no such thing as an "array to pointer." What you might be asking is "array of pointers."

An array of pointers is just that, an array in which the variables are pointers. In C this would be an array of pointer variables that are each 4 bytes in size. It is declared like this:

int *pointers[3];

A pointer to an array is a pointer that points to the whole array. For example, in C if you have

int numbers[5][10];

int (*pointerToArray)[10] = numbers + 2;

pointerToArray points to the third element of numbers, which is itself an array.

Answer 3

The following program demonstrates the difference and also highlights one of the dangers of getting the two mixed up.

The program begins by declaring two static arrays, each with 5 elements. The first, a, is an array of int, while the second, b, is an array of pointer to int. We then initialise both arrays with values 1 to 5. Note that since array b is an array of pointers, we must give it some memory to point at. We could simply point at the individual elements of a if we wished, but in this example we'll allocate new memory from the heap instead.

Next, we create some pointers to point at these arrays. p1 points to a, while p2 points to b. Note that becuase b is an array of pointers, p2 needs an extra level of indirection, hence we use ** rather than * as we did with p1. We'll come to p3 later, but note that there is only one level of indirection, and that it is currently pointing at element b[0].

Next we print all the details relating to all our variables. You will note that the address of a is the same as the value of a, and that the address of b is the same as the value of b. This is because a and b are both references to the arrays; that is, they each refer to the start address of the memory allocated to the arrays. They are not variables like pointers, so you cannot change what address they refer to once they are assigned.

When we dereference a (using *a), we're effectively looking at the value of a[0] (which is 1). You will note that &a, a, and &a[0] all refer to the same memory address. By the same token, when we dereference b (using *b) we're dereferencing the value of b[0] which is a pointer. So to dereference that pointer we use an extra level of indirection (**b) to obtain the value.

After listing all the addresses and values of the array elements (including the dereferenced pointers in b), we examine the pointers. Note that the address of p1 and p2 are different to that of &a and &b. Remember that p1 and p2 are pointers, and therefore they each have their own memory address. However, the remaining details are the same as for a and b.

At this stage, p3 is a valid pointer so its value is the same as *b, b[0] and *p2, while its dereferenced value (*p3) is the same as **b, *b[0] and **p2. However, it has undefined behaviour, as we'll see after we increment the pointers.

Although p1 is a pointer to an array of int, it is really just a pointer to int. So when we increment p1 it increments by sizeof(int) and therefore points at the address of a[1] with the value 2. Similarly, p2 is a pointer to a pointer to an int, thus it ends up pointing at the pointer stored in b[1] which points to an integer elsewhere in memory (on the heap) with the value 2.

p3 is also a pointer to an int, like p1, but we assigned it the memory address stored in b[0], which was 0x00350990 (see the example output below the program). This is never a good idea. Although that address is perfectly valid, as soon as we increment p3 we're in uncharted waters because we end up pointing at memory address 0x00350994 (a difference of 4 bytes, or sizeof(int) bytes). But the address we probably expected was the one stored in b[1], which is 0x003509C0, a full 48 bytes away! Remember that we allocated memory to b's elements one at a time, so there's no guarantee those allocations will be contiguous. In fact, I'd be more surprised if they were!

The lesson here is that if you're going to point at arrays of pointers and wish to navigate through the array, do make sure you point at the array itself (as we did with p2), and never to the value in one of its elements (as we did with p3). Otherwise there's no telling what you'll end up pointing at.

#include<iostream>

int main()

{

int a[5]; // array of int

int* b[5]; // array of pointer to int

// Initialise arrays:

for(int i=0; i<5; ++i)

{

a[i] = i+1;

b[i] = new int(i+1);

}

int* p1 = a; // pointer to array of int

int** p2 = b; // pointer to array of pointer to int

int* p3=b[0]; // undefined behaviour!

std::cout<<"ARRAYS\n"<<std::endl;

std::cout<<"&a=0x"<<&a;

std::cout<<"\ta=0x"<<a;

std::cout<<"\t*a="<<*a<<std::endl;

std::cout<<"&b=0x"<<&b;

std::cout<<"\tb=0x"<<b;

std::cout<<"\t*b="<<*b;

std::cout<<"\t**b="<<**b<<std::endl;

std::cout<<"\nELEMENTS\n"<<std::endl;

for(int i=0; i<5; ++i)

{

std::cout<<"&a["<<i<<"]=0x"<<&a[i];

std::cout<<"\ta["<<i<<"]="<<a[i]<<std::endl;

}

std::cout<<std::endl;

for(int i=0; i<5; ++i)

{

std::cout<<"&b["<<i<<"]=0x"<<&b[i];

std::cout<<"\tb["<<i<<"]=0x"<<b[i];

std::cout<<"\t*b["<<i<<"]="<<*b[i]<<std::endl;

}

std::cout<<"\nPOINTERS\n"<<std::endl;

std::cout<<"&p1=0x"<<&p1;

std::cout<<"\tp1=0x"<<p1;

std::cout<<"\t*p1="<<*p1<<std::endl;

std::cout<<"&p2=0x"<<&p2;

std::cout<<"\tp2=0x"<<p2;

std::cout<<"\t*p2=0x"<<*p2;

std::cout<<"\t**p2="<<**p2<<std::endl;

std::cout<<"&p3=0x"<<&p3;

std::cout<<"\tp3=0x"<<p3;

std::cout<<"\t*p3="<<*p3<<std::endl;

std::cout<<"\nIncrementing pointers...\n"<<std::endl;

++p1;

++p2;

++p3;

std::cout<<"&p1=0x"<<&p1;

std::cout<<"\tp1=0x"<<p1;

std::cout<<"\t*p1="<<*p1<<std::endl;

std::cout<<"&p2=0x"<<&p2;

std::cout<<"\tp2=0x"<<p2;

std::cout<<"\t*p2=0x"<<*p2;

std::cout<<"\t**p2="<<**p2<<std::endl;

std::cout<<"&p3=0x"<<&p3;

std::cout<<"\tp3=0x"<<p3;

std::cout<<"\t*p3="<<*p3<<std::endl;

std::cout<<std::endl;

for(int i=0; i<5; ++i)

delete( b[i] );

}

Output:

ARRAYS

&a=0x002CFBBC a=0x002CFBBC *a=1

&b=0x002CFBA0 b=0x002CFBA0 *b=00350990 **b=1

ELEMENTS

&a[0]=0x002CFBBC a[0]=1

&a[1]=0x002CFBC0 a[1]=2

&a[2]=0x002CFBC4 a[2]=3

&a[3]=0x002CFBC8 a[3]=4

&a[4]=0x002CFBCC a[4]=5

&b[0]=0x002CFBA0 b[0]=0x00350990 *b[0]=1

&b[1]=0x002CFBA4 b[1]=0x003509C0 *b[1]=2

&b[2]=0x002CFBA8 b[2]=0x003509F0 *b[2]=3

&b[3]=0x002CFBAC b[3]=0x00350A20 *b[3]=4

&b[4]=0x002CFBB0 b[4]=0x00350A50 *b[4]=5

POINTERS

&p1=0x002CFB88 p1=0x002CFBBC *p1=1

&p2=0x002CFB7C p2=0x002CFBA0 *p2=0x00350990 **p2=1

&p3=0x002CFB70 p3=0x00350990 *p3=1

Incrementing pointers...

&p1=0x002CFB88 p1=0x002CFBC0 *p1=2

&p2=0x002CFB7C p2=0x002CFBA4 *p2=0x003509C0 **p2=2

&p3=0x002CFB70 p3=0x00350994 *p3=-33686019

Answer 4

A pointer is a variable that may contain a memory address, or NULL (zero).

An array is collection of data, usually residing in a contiguous block of memory, where every element is accessed as an offset from the beginning of the array.

Answer 5

pointer is use to hold address of another variable whereas array is a collection of elements of similar datatype

Answer 6

Pointer holds an address Array holds values