Thread: Pointer school

I prepared this simple program in hopes that it will help explain pointers to a 2nd semester C++ programming class. Do you see anything inaccurate or particularly confusing in any of my comments?

I'm a little worried about this line in particular:

Code:

// It also stores an int** pointer to the 2-d array itself,
//   which holds the beginning address of the block of
//   int* pointers.

Anything wrong with that?

Thanks for looking.

Code:

#include <iostream>
using namespace std;

int main () {
  int i,j;
  int iarr[4][2] = {{1,2},{3,4},{5,6},{7,8}};
  // When we declare a 2-dimensional int array, the compiler:
  //   allocates a contiguous block of memory in which to 
  //   store the requested number of ints.
  // It also allocates another contiguous block of memory    // NO
  //   in which it stores int* pointers to the 1-dimensional
  //   arrays representing the "rows" (the last dimension)
  //   of the int array.
  // It also stores an int** pointer to the 2-d array itself,    // NO
  //   which holds the beginning address of the block of
  //   int* pointers.

// code deleted ...

  return 0;
}

>> int iarr[4][2] = {{1,2},{3,4},{5,6},{7,8}};

When you declare that array, you will get exactly 4 * 2 * sizeof( int ) bytes of contigious memory. No more, no less. The compiler doesn't need an array of pointers to index the array since it already knows the dimensions a priori. That is, when you request the value at iarr[r][c], the compiler simply generates an offset of r * COLUMNS + c into a 1-dimensional array.

I'm not sure I understand what you mean. Just to clarify, when I said 'a one dimensional array', I was of course referring to the symbol 'iarr' itself, just that, as far as the compiler is concerned, it's really just a 'flat' block of memory. Incidentally, this is exactly why the compiler needs to know the number of columns in a two dimensional array, but not the number of rows. Consider the following:

Code:

void ok( int array[ ][ 2 ] )
{	}

void noway( int array[ 4 ][ ] )
{	}

Without the column information, it would be impossible for the compiler to generate the linear offset of say, arr[ 2 ][ 1 ], which would be sizeof( int ) * 2 * COLUMNS + 1 == 20 bytes from the start address of arr (assuming 4-byte ints, of course). Does that make sense?

>> Is it correct to say that the type of iarr is int[][2] and the type of iarr[0] is int[2]?

Yes. That's right.

If you print its sizeof, you should see that it is the size of 2 ints, so the type of iarr[0] must be int[2].

Originally Posted by R.Stiltskin

In my "defense", my confusion comes from errors like this:

Code:

#include <iostream>
using namespace std;

int main () {
  int i,j;
  int iarr[][2] = {{1,2},{3,4},{5,6},{7,8}};
  int parr = iarr[0];

  return 0;
}

I know the assignment "int parr = iarr[0]" is illegal -- it's here specifically to see the compiler's error message, which is:
"point.cc:7: error: invalid conversion from 'int*' to 'int'"

So the compiler states that the type of iarr[0] is 'int*', and I've been interpreting that as saying that iarr[0] is an int pointer. Apparently that is incorrect. So exactly what does it mean when the compiler calls something an 'int*'?

Statically declared arrays are a special case, but 'generally'(This is subject of much debate, so someone will shoot me in my face for this), arrays are the same as pointers.

In this case, iarr[0] is a statically defined array, and thus, if you print the address of iarr, you will be getting the address of iarr[0]. If you do this with a pointer, you will be printing the address of the pointer itself, and the address of the first element if you do ptr[0]. E.g., address of a statically defined array is the address of the first element. An address of a pointer is the address of pointer itself.

It's also worth mentioning that, if you pass your array to a function by a pointer, it will degenerate to a pointer. This is why your compiler is calling the int array a pointer, because, in many situations, it is.

Originally Posted by R.Stiltskin

In my "defense", my confusion comes from errors like this:

Code:

#include <iostream>
using namespace std;

int main () {
  int i,j;
  int iarr[][2] = {{1,2},{3,4},{5,6},{7,8}};
  int parr = iarr[0];

  return 0;
}

I know the assignment "int parr = iarr[0]" is illegal -- it's here specifically to see the compiler's error message, which is:
"point.cc:7: error: invalid conversion from 'int*' to 'int'"

So the compiler states that the type of iarr[0] is 'int*', and I've been interpreting that as saying that iarr[0] is an int pointer. Apparently that is incorrect. So exactly what does it mean when the compiler calls something an 'int*'?

This is because iarr[0] is of type int[n] (ie a 1D array of int). When assigning arrays, it decays to a pointer. So what the compiler really sees is the int array which you try to assign, which makes it decay to int*, which it then tries to assign, but cannot assign int* to int.

Originally Posted by R.Stiltskin

is "decays to a pointer" in this case just a colloquial way of saying "is implicitly converted to a pointer"? This interpretation seems compelling since as far as I know the only thing you can assign array to is a pointer of the appropriate type. True?

Yes.

have you really tried that hard?

Code:

	int x[4][2];
	int (*y)[2];
	y=x;

Originally Posted by R.Stiltskin

but there doesn't seem to be any kind of pointer to which I can assign iarr itself. Depending on which silly thing I try to do, the compiler errors give
the type of iarr as either int[4][2] or int(*)[2], but there seems to be no way to declare a pointer to either of those types.
Or am I overlooking something?

Try:

Code:

int iarr[4][2];
int (*p)[2] = iarr;

p would then be a pointer to an array of 2 ints.