3

We just started going over pointers in my C/C++ class, and I'm a bit confused at how they work. I am presented with this problem:

Assume you have declared a multi-dimensional array char ma[5][30]. What is the address of the element "ma[0][0]"? Use two (2) different ways to assign the address to a pointer variable, p. (Do not give a concrete address for ma[0][0] - this will vary each time the program is run, based on the memory allocated.)

I know how much this community frowns on providing the "answers" to a homework problem. I don't need the answer, but hopefully someone can explain to me how I can use a pointer to get the address of an element in an array?

Konrad Rudolph
  • 530,221
  • 131
  • 937
  • 1,214
rphello101
  • 1,671
  • 5
  • 31
  • 59
  • 1
    It is disappointing to see so many answers performing questionable casts when you can simply use the features of the language and use `char *p = *ma;`, which is a completely standard C and C++ way to get the address of the first element of a two-dimensional array of `char`. – Eric Postpischil Sep 18 '13 at 01:54

6 Answers6

4

The two ways would be

char* p1 = (char*)ma;
char* p2 = &ma[0][0];

The first one works because "ma" is already a pointer to a location in memory where the array is stored.

The second one works using the address-of operator (&). &ma[0][0] translates to "the address of ma, element 0,0"

Johan Henriksson
  • 687
  • 3
  • 10
3

Lets say you have a pointer p; Grab the memory with the & operator.

p = &ma[row][col];

Or you can have a pointer from the variable name of the array.

p = ma;

Then you use pointer arithmetic to access this.

p = p + (row * num_per_col + col);
pippin1289
  • 4,861
  • 2
  • 22
  • 37
  • Assuming the pointer `p` is declared as a pointer to element (i.e. `char *`), the second assignment is invalid. `ma` decays to `char (*)[30]`, which cannot be assigned to `char *` pointer. – AnT stands with Russia Sep 17 '13 at 21:43
1

There are actually three straightforward ways to obtain a pointer to the element at index (0,0), two of which are cast-free:

char const* const p1 = (char const*)ma;
char const* const p2 = ma[0];
char const* const p3 = &ma[0][0];

The reason why these work is due to the memory layout of ma. Your matrix is just a series of 150 consecutive chars (i.e. 150 bytes). C allows us to decay arrays to pointers to their respective first element whenever we wish to. In fact, this mechanism is so promiscuous, that people are sometimes led to believe there to be no difference between an array and a pointer.

Let's start with the second line (p2). ma[0] is a one-dimensional array of 30 elements of type char and C allows us to have that expression decay into a pointer, pointing at the very first element in the 30 char array. The third line (p3), explicitly fetches the address of element [0][0]. To use this, we don't even have to understand how the memory is laid out.

The first line (p1) is a bit nasty, because it involves a cast. Normally, we could have ma decay to a pointer to a char array, since the first element of ma is an array, not a char. But we know that the very first element of that array is the char we are looking for, so we rely on the array to have no padding before the first element and reinterpret the address of the entire first array as the address of its first char.

bitmask
  • 32,434
  • 14
  • 99
  • 159
  • Since you know a cast is nasty, why not just use `char const * const p1 = *ma`? `ma` names the array, so it is automatically converted to a pointer to the first element. That is, it becomes `&ma[0]`. Then `*ma` is `*&ma[0]`, which is `ma[0]`. That is also an array, so it is automatically converted to a pointer to its first element, which is `&ma[0][0]`. – Eric Postpischil Sep 18 '13 at 01:52
  • @EricPostpischil: Yes, I'm aware all three options do the same. That was the original question! – bitmask Sep 18 '13 at 07:56
0

You can get it like 

&ma[0][0];

If you have a multidimensional array defined as int [][], then x = y[a][b] is equivalent to x = *((int *)y + a * NUMBER_OF_COLUMNS + b); (Reference Answer)

Community
  • 1
  • 1
Shumail
  • 3,103
  • 4
  • 28
  • 35
0

Except when it is the operand of the sizeof or unary & operators, or is a string literal being used to initialize another array in a declaration, an expression of type "N-element array of T" will be converted ("decay") to an expression of type "pointer to T", and the value of the expression will be the address of the first element of the array.

Assuming the declaration

char ma[5][30];

then all of the following are true:

  1. The expression ma has type "5-element array of 30-element array of char". Unless ma is an operand to either sizeof or unary &, it will be converted to an expression of type "pointer to 30-element array of char", or char (*)[30], and its value will be the address of the first element in the array, or &ma[0].

  2. The expression ma[i] has type "30-element array of char". Unless ma[i] is an operand to either sizeof or unary &, it will be converted to an expression of type "pointer to char", or char *, and its value will be the address of the first element in the array, or &ma[i][0].

  3. The expression ma[i][j] has type char.

  4. The expression &ma has type "pointer to 5-element array of 30-element array of char, or char (*)[5][30].

  5. The expression &ma[i] has type char (*)[30].

  6. The expression &ma[i][j] has type char *.

  7. The values of the expressions ma, &ma, ma[0], &ma[0], and &ma[0][0] are all the same; the address of the array is the same as the address of the first element of the array.

Note that the types char (*)[30] and char (*)[5][30] are not compatible with char *, or with each other; if you want to assign a value of those types to a variable of type char *, you will need to use an explicit cast, such as char *p = (char *) ma;.

Edit

Types matter; pointer arithmetic is based on the pointed-to type, so an expression like ptr+1 will give different results based on the type that ptr points to. For example:

#include <stdio.h>

int main( void )
{
  char ma[5][30] = {{0}};

  char (*p0)[5][30] = &ma;
  char (*p1)[30]    = &ma[0];
  char *p2          = &ma[0][0];

  printf("%5s%-15s%-15s\n"," ","ptr","ptr+1");
  printf("%5s%-15s%-15s\n"," ","-----","-----");
  printf("%-5s%-15p%-15p\n","p0", (void *) p0, (void *) (p0+1));
  printf("%-5s%-15p%-15p\n","p1", (void *) p1, (void *) (p1+1));
  printf("%-5s%-15p%-15p\n","p2", (void *) p2, (void *) (p2+1));

  return 0;
}

I create three pointers of different types; p0 is of type char (*)[5][30] and takes the result of &ma, p1 is of type char (*)[30] and takes the result of &ma[0], and p2 is of type char * and takes the result of &ma[0][0]. I then print the value of each pointer, than the value of each pointer plus 1. Here are the results:

     ptr            ptr+1
     -----          -----
p0   0x7fff36670d30 0x7fff36670dc6
p1   0x7fff36670d30 0x7fff36670d4e
p2   0x7fff36670d30 0x7fff36670d31

Each pointer starts out with the same value, but adding 1 to the pointer gives different results based on the type. p0 points to a 5x30-element array of char, so p0 + 1 will point to the beginning of the next 5x30-element array of char. p1 points to a 30-element array of char, so p1 + 1 points to the next 30-element array of char (ma[1]). Finally, p2 points to a single char, so p2 + 1 points to the next char (ma[0][1]).

John Bode
  • 119,563
  • 19
  • 122
  • 198
-2

Or you get the value at (x,y) from the array with addr = &ma[0][0] + sizeof(<type of array>)*columns * x + sizeof(<type of array>) * y

arc_lupus
  • 3,942
  • 5
  • 45
  • 81