why a pointer can be assigned value?

Question

I have a puzzle here:

int *a=*b;
a[1]=3;
a[2]=5

a is a pointer array and is assigned value as b. In my understanding, a[]should be a address, so why in practice we can assign value to the place the pointer (in this case a[]) to? Any explain?

Answer 1

I'm assuming this is C, or the C subset of Objective C/C++, since C+, Java, PHP, and the other C-like languages don't use pointers.

Use code tags and a single statement per line.

The statement

int *a = *b;

Creates a as a pointer to int. Not a pointer to pointer to int, a pointer to an int.

It then sets the current address in a to be a dereference of b, whatever b is. You did not show the declaration of b. Unless b is of type int **, you should be getting a compiler warning.

a is not a pointer array. a is a pointer to an int. It could point to a single int, or it could be made to point to an array of ints. The compiler can't tell the difference..

If b is of type int **, or pointer to pointer to int, then your statement dereferences one of those pointers and makes a point to the first sub-array inside b.

The code

a[1] = 3;

assumes that a is a pointer to an array of integers, and since the compiler can't do any range checking, it tries to index into the array and save a value to the second int in the block of memory that a points to. If a does not point to a block of memory large enough to contain at least 2 integers, this statement may crash on a modern computer using protected memory, it might also just overwrite the memory that follows.

As @EdS. points out in a comment below, this is known in the business as

"undefined behavior"

If you're going to use a C pointer like this, the burden is on you to make sure that it really points to valid memory, and if you're going to use a pointer as if it's an array, you the burden is on you to make sure that you don't exceed the bounds of the memory pointed to by the pointer.

Answer 2

But let's answer to your question:

Here am I going step by step through your code (though I modified it a bit for the purpose of the example), and show you what it is doing in a fake memory, so you get the idea:

int b[4];

here you allocate 4 cells of memory and make b a label for a memory cell containing the address of the first memory cell:

variable     b                      
address      0x1   0x2 0x3 0x4 0x5 
memory      [0x2] [   |   |   |   ]

then:

int* a = b;

here you allocate a new memory cell that can contain an address, as it is declared with a pointer type, and you assign to it the content of the b memory cell:

variable     b                       a
address      0x1   0x2 0x3 0x4 0x5   0x6
memory      [0x2] [   |   |   |   ] [0x2]

then:

a[1]=3;
a[2]=5;

you're setting a value to a[1] which translates to *(a+1) using pointers arithmetics, which is the content of address 0x2 + 1 i.e. content of 0x3. Same thing with a[2]. The memory is now:

variable     b                       a
address      0x1   0x2 0x3 0x4 0x5   0x6
memory      [0x2] [   |  3|  5|   ] [0x2]

I hope this ASCII will make it a bit more clear how arrays are working! And you should definitely read the Kernighan and Ritchie book, as well as this documentation which both explain very well how the whole memory is managed, and the pointers arithmetics, and arrays.