Array of pointers to arrays

Question

I am new to C programming and this is my problem:

I want to store the first value of each array in a new array, then the second value of each array in a new array and so on.

I could declare the array of pointers but I don't know how I use it!

Please I need Help.

int main()
{
    int t1[4]={0,1,2,3};
    int t2[4]={4,5,6,7};
    int t3[4]={8,9,10,11};
    int t4[4]={12,13,14,15};
    int *tab[4]={t1,t2,t3,t4};
    int i,j,k,l;
    for (i=0; i<4;i++)
    {
        printf("%d\t", *tab[i]);
    }

    return 0;
}

When I do this, I store just the first value of each array.

Answer 1

int* (*a[5])[5][5][5] declares an array of 5 pointers to a 3d array of pointers to ints

int* (*(*a[5])[5])[5][5][5] declares an array of 5 pointers to an array of 5 pointers to a 3d array of pointers to ints.

#include <stdio.h>

int main()
{
    int t1[4]={0,1,2,3};
    int t2[4]={4,5,6,7};
    int t3[4]={8,9,10,11};
    int t4[4]={12,13,14,15};
    int (*tab[4])[4]={&t1,&t2,&t3,&t4};
    int i,j,k,l;
    for (i=0; i<4;i++)
    {
        printf("%d\t", (*tab[i])[1]);
    }

    return 0;
}

There's a difference between t2 and &t2. Though they have the same value their types are different. int [4] vs int (*)[4]. The compiler will throw a warning (clang) or error (gcc).

int a[4] is conceptually at compiler level a pointer to an array of 4 as well as being the array itself (&a == a).

int (*a)[4] is conceptually at compiler level a pointer to a pointer to an array of 4 as well as being a pointer to the array itself (a == *a) because it's pointing to an array type where the above is true.

At runtime, if an int * and int (*a)[4] point to the same address, they are physically identical – it's just an address, the same address. The type only matters in how the compiler interprets and produces arithmetic operations with that address and the assembly it actually outputs based on the type. You can cast the address to any type you want in order to achieve the desired code output to manipulate data at the address it holds. An int a[4] type however is physically the array itself but you use it as if there is a pointer a to it in memory which is given the same address as the array itself. A pointer to int a[4] means 'a pointer to the address range a that is treated by the compiler as an array with int element width, where the compiler treats the start of the array as if it were a pointer to the array', and any operations on that type will be consistent in a derefernce chain i.e. you must at compiler level use (*a)[0] to access the first element if the type is a pointer to an array, but if you cast the same address to int * then you need to use a[0] to access the member.

Answer 2

Your terminology is a little bit all over the place. I think the easiest way to answer your question is to go through your code line by line.

int main()
{
int t1[4]={0,1,2,3};      //Declares a 4 integer array "0,1,2,3"
int t2[4]={4,5,6,7};      //Declares a 4 integer array "4,5,6,7"
int t3[4]={8,9,10,11};    //Declares a 4 integer array "8,9,10,11"
int t4[4]={12,13,14,15};  //Declares a 4 integer array "12,13,14,15"
int *tab[4]={t1,t2,t3,t4};//Declares a 4 pointer of integers array "address of the first element of t1, address of the first element of t2, ..."
int i,j,k,l;              //Declares 4 integer variables: i,j,k,l
for (i=0; i<4;i++)
 {
  printf("%d\t", *tab[i]); //print out the integer that is pointed to by the i-th pointer in the tab array (i.e. t1[0], t2[0], t3[0], t4[0])
 }

 return 0;
 }

Everything you are doing seems ok until your loop. You are showing only the first integer of every array because you are not going through them. To iterate over them, your code should look like this:

for (i=0; i<4;i++)
{
   for (j=0; j<4; j++)
   {
      printf("%d\t", *(tab[j] + i));
   }
}

The above code uses two loop counters, one (the i) to go through the positions in the array (first value in the array, second value in the array, etc.); the other to go through the different arrays (the j). It does this by retrieving the pointer stored in tab[j] and creating a new pointer that has the right offset to show the value for the ith column. This is called pointer arithmetic (there is additional information about pointer arithmetic here)

Most people find the syntax *(tab[j] + i) to be clunky, but it is more descriptive of what is actually happening. In C, you can rewrite it as tab[j][i], which is much more usual.