C编程中的整数数组

Question

I have this homework at school where I have to evaluate what is the output to the following code:

#include<stdio.h>
int main()
{
    int a[2][2] = {1, 2, 3, 4};
    int i, j;
    int *p[] = {(int*)a, (int*)a+1, (int*)a+2};
    for(i=0; i<2; i++)
    {
        for(j=0; j<2; j++)
        {
            printf("%d, %d, %d, %d\n",
              *(*(p+i)+j), *(*(j+p)+i),
              *(*(i+p)+j), *(*(p+j)+i));
        }
    }
    return 0;
}

the output is:

1,1,1,1
2,2,2,2
2,2,2,2,
3,3,3,3

What I didn`t study, yet I have it as a homework, are these lines:

int a[2][2] = {1, 2, 3, 4};
int *p[] = {(int*)a, (int*)a+1, (int*)a+2};

I also don't understand what is the difference between *(*(p+i)+j) and *(*(i+p)+j) . Thank you.

Answer 1

Actually you need to understand the how compiler seeing the array. as you have mentioned *(*(p+i)+j) and *(*(i+p)+j)

Actually Compiler see *(*(p+i)+j) as *(*(address of P + number of increment in memory block)+number of increment in memory block)

suppose p is the base address with value 5000 and i=2, j=3

*(*(p+i)+j) = *(*(5000+2)+3) = *(*(5008)+3)

*(*(i+p)+j) = *(*(2+5000)+3) = *(*(5008)+3)

As you can see both the result came same. I have supposed compiler assigned integer as 4 byte. Hope this will help you.

Answer 2

int a[2][2] = {1, 2, 3, 4};

That is a horrible way of writing int a[2][2] = {{1, 2}, {3, 4}};

It is a 2d array of numbers. Hence, a may be interpreted to be a pointer to it's first element, ie the address of {1, 2}. In the same way, a + 1 is the address of {3, 4}.

int *p[] = {(int*)a, (int*)a+1, (int*)a+2};

That is parsed as int *p[] = {(int*)a, (int*)(a+1), (int*)(a+2)};

Nope it is actually ((int*)a)+1 and so on.

Each cast (int*) converts a from a pointer to the array {1, 2} to a pointer to the int 1.

It fills an array of int* with the addresses of the first int's in the three two dimensional arrays at a , a + sizeof(int[2]) and a + 2 * sizeof(int[2]) . The third is nonexistent, being a pointer 'past the end'.

It fills the array with poiinters to 1, 2, 3 even though a is not a 1 dimensional array.

All of these are the same.

*(*(p+i)+j), *(*(j+p)+i),
*(*(i+p)+j), *(*(p+j)+i));

That is (p + i) == (i + p) (cummutativity) and (*(j+p)+i) == p[j][i] and (*(p+i)+j) == p[i][j] . But p[x][y] == *((int*)a + x) + y) == a[x + y] So p[j][i] == p[i][j] == (a[i + j])

*(array_name + i) in C is primarily used to confuse people when array_name[i] is perfectly understandable.

Answer 3

You're touching on multi-dimensional arrays, pointers, and double dereferencing: either you're a few months (maybe closer to a year behind) or your teacher's hoping to shock you into taking the class seriously (many people assume CS classes will be easy). Or maybe she's a sadist. Hard to tell, really.

"I also don't understand what is the difference between ( (p+i)+j) and ( (i+p)+j)" There is no difference. That is why each line of output repeats the same number. Each line evaluates to the same thing mathematically. I think this is an attempt to demonstrate that a pointer is just a number.

I'll try to explain this plainly: memory is a contiguous sequence of data. Your first line demonstrates this. int a[2][2] = {1, 2, 3, 4}; focus on the last part {1, 2, 3, 4} This is literally a list of data. The first data is 1, the second is 2, the third is 3, etc. You could just as easily reverse this - the data doesn't have to match the sequence at all. For example, {100, 43, 512, -1} would have produced the output:

100, 100, 100, 100 43, 43, 43, 43 512, 512, 512, 512 -1, -1, -1, -1 And, in your computer's memory, these are stored contiguously; right one after another.

Now, in what is typically considered bad form, your teacher chose to define this single list as a list of two lists (in CS terms, an array of two arrays). a[2][2] is fundamentally the same as stating "a is an array of two arrays with two elements each", or "I've got two lists with two things on them".

Because all memory is contiguous, both of those arrays are contiguous with eachother. In memory, it is the same as if the second array was just added to the end of the first array. Which is why you can have two arrays of two elements each represented as one array of four elements (2 * 2 = 4).

Another way she could have written that line is: int a[2][2] = { { 1, 2 }, { 3, 4 } }; or int a[4] = { 1, 2, 3, 4 }; or int a[] = { 1, 2, 3, 4 };

I assume you at least understand a little bit about coding, so I won't insult you with explaining i and j or the loops.

...which leaves this gem:

int *p[] = {(int*)a, (int*)a+1, (int*)a+2};

'p' is what we'd call an array of pointers. Pointers are a number that represents a location in memory. All memory is contiguous. That means that if you started at the first "int" that could be stored in memory, and moved forward an int at a time until you got to the pth int, you would be at the place in memory p represents. We call them pointers because they "point" into memory. Also, arrays are pointers too. "a" points to its first element. so we could rewrite that first line again:

int *a = { 1, 2, 3, 4 };

(disclaimer: it may not compile, never seen code written like that before, but it's basically what we already do for text.) and the third line can be rewritten like this:

int *p[] = (int *)a;

hope I explained it to you well enough!

also, tell your teacher that code like this would not even be acceptable if accompanied by a series of comically depressing and apologetic comments that also explain why it was decided to write the code in this way, and that you would be better served being shown code acceptable for use in the real world rather than this academic nonsense.