关于C中的指针

Question

I started to read a few articles about pointers in C and I've got one example that I don't understand.

The example is from here: http://en.wikibooks.org/wiki/C_Programming/Pointers_and_arrays

Here it is:

Let's look at a slightly different problem. We want to have a two dimensional array, but we don't need to have all the rows the same length. What we do is declare an array of pointers. The second line below declares A as an array of pointers. Each pointer points to a float. Here's some applicable code:

float  linearA[30];
 float *A[6];

 A[0] = linearA;              /*  5 - 0 = 5 elements in row  */
 A[1] = linearA + 5;          /* 11 - 5 = 6 elements in row  */
 A[2] = linearA + 11;         /* 15 - 11 = 4 elements in row */
 A[3] = linearA + 15;         /* 21 - 15 = 6 elements        */
 A[4] = linearA + 21;         /* 25 - 21 = 4 elements        */
 A[5] = linearA + 25;         /* 30 - 25 = 5 elements        */

 A[3][2] = 3.66;          /* assigns 3.66 to linearA[17];     */
 A[3][-3] = 1.44;         /* refers to linearA[12];           
                             negative indices are sometimes useful.
                             But avoid using them as much as possible. */

My question is why A[0] is a pointer only to five elements and not to ALL of linearA , since the name of an array is a pointer to its first member.

And A[1] = linearA + 5; is 6 elements in a row -- for the same reason? Isn't A[1] supposed to be a pointer to the 6th member of linearA ?

Can someone explain where is my mistake?

Answer 1

Except in a few exceptions, in C an array name is converted to a pointer to the first element of the array. linearA is an array 30 of float and in the expression:

A[0] = linearA;

it is converted to a pointer to float .

A is an array 6 of pointer to float . The element of A are of type pointer to float . So A[0] is a pointer to float and not a pointer to an array.

And A[i][j] in C is equivalent to *(A[i] + j) so A[i][j] is a float (dereferencing a pointer to float yields a float ).

Answer 2

A[0] is a pointer to the 1st element of linearA . Since linearA is a contiguous array, this pointer actually allows to access any of the linearA 30 elements by adding an appropriate offset. However in this piece of code you emulate a 2D array by pointing to different offsets in the linearA array. The result is 2D-like array addressing: A[n] brings you to the location (ie offset in the linearA ) of your n-th row and A[n][m] brings you to the m-th element inside this row.

Answer 3

It's because this line sets up an array of 6 pointers to float :

float *A[6];

And this line sets the first of those pointers to the first element of the 30.

A[0] = linearA; 

Therefore each element of A points to a subsection of the original array. You have to assign them though - they'll initially point to random addresses.

The first one is the initial address ( &linearA[0] ) and the next five are the following ones. These are accessible as A[0][0] to A[0][5] . Because of the way arrays correspond to pointers, you can keep going up, so long as you don't exceed the 30th.

But you can assign A[n] to any part of the array you like. As long as it's part of the original array, it will point that member, and the next 5 (or however many you want).

For example, by pointing A[1] to &linearA[6] , you would effectively be setting up a two dimensional array (it would resemble one, but not behave as one).

Answer 4

My question is why A[0] is a pointer only to five elements and not to ALL of linearA, since the name of an array is a pointer to its first member.

you setup A[0] to point to linearA which is the first float in the array, A[0] is a pointer and thus doesn't know anything about what it points to part from an address. So A[0] is not a pointer to only five elements it points to where the array starts and has no concept of where the array ends.

And A[1] = linearA + 5; is 6 elements in a row -- for the same reason? Isn't A[1] supposed to be a pointer to the 6th member of linearA?

yes A[1] points to the sixth element but as said before its a starting address.

Answer 5

The example you posted shows a somewhat esoteric technique called Iliffe vector , which is one possible way to implement jagged arrays in C. A jagged array is a matrix in which each row has a different length.

Since arrays are one-dimensional in C, you are creating a single array linearA containing all the elements, which is interpreted as a sequence of rows, each of a different size. The pointer array A contains pointers to the first element of each row that allow you to access elements using row and column indices.

The code displays several interesting features of C pointers and arrays:

linearA + 5

Pointer arithmetic: adding an integer to a pointer (or array) gives you a pointer pointing n elements after the original pointer.

A[3][2] = 3.66;

This nice syntax allows you to think of this structure as a two-dimensional matrix.

Also, and this is probably the main point of the example, pointers and arrays are interchangeable . Here, A[3] is a pointer to float, since A was defined as an array of pointers to floats; appending [2] gives us the element 2 places after the one pointed by the original pointer. This is similar to the pointer arithmetic above, only in this case the pointer is dereferenced. Actually, array access is defined in terms of pointers so X[5] is equivalent to *(X+5) .

A[3][-3]

This shows that there is nothing stopping you from accessing an element outside of a given row. In this case, you are accessing the element 3 places before the one pointed by A[3] . This is something that is rarely needed, and it only works in this case because you built the matrix to have contiguous elements. Usually, accessing elements outside the allocated range of an array will crash your program.

Finally, to answer your question:

And A[1] = linearA + 5; is 6 elements in a row -- for the same reason? Isn't A[1] supposed to be a pointer to the 6th member of linearA ?

As pointers and arrays are interchangeable, A[1] is both a pointer to the sixth element in linearA and an array starting from the sixth element in linearA . There is nothing in the language saying that the latter is 6 elements long, you have to implement that logic in your code.