4

I've been playing around with pointers to help get a better understanding. I have declared a as a pointer to an array of integers of length 3 and b as an array of integers of length 3. I then point a at b. 

int main()
{
    int (*a)[3];
    int b[3] { 2, 4, 6 };
    a = &b;
    a[0][0] = 8;
    // This prints out 8 and 8.
    std::cout << a[0][0] << "\t" << b[0];

    // This prints out 0x28fecc and 8.
    std::cout << a[0] << "\t" << b[0];

    return 0;
}

To access an element of b through the pointer a, I have to do a[0][0] as if a were an array of arrays. This is compared to declaring a pointer to an array of integers using the new keyword where I can just output c[0].

int* c = new int[3] { 2, 4, 6 };
std::cout << c[0];

Why is this?

Many thanks, George

Improve this question
6
  • Ah, so c points to the first element of the array (which is an integer), rather than the address of the array? I understand (in this example) that the array is a sequence of integers sequentially in memory. Does an array have an address itself? (I assumed the address of an array was the memory address of its 1st element)? Commented Jan 7, 2014 at 16:43
  • 1
    Yes, the array has an address, and it is the same as the address of the first element. But a pointer to an array has a different type to a pointer to an int (or whatever), so you need different syntax to access the array elements through it. Commented Jan 7, 2014 at 16:45
  • Do yourself a favor: next time you're tempted to write something like: int (*a)[3];, just walk away from the keyboard for a while, repeat "I'm writing C++ not C, so I don't need to do ugly things like that." about a dozen times, and only when you've convinced yourself that simplicity is good, come back and write what you really wanted to (which I'm quite certain will be something different from that). Commented Jan 7, 2014 at 16:45
  • The address of the first element and the array are one and the same. c is a pointer to int because this says so: int* c, independently of what is on the RHS of the initialization. new returns pointer to an array (or the first element), and arrays themselves decay into pointers to their first element under many circumstances. Fortunately you don't really have to deal with this kind of stuff in modern C++. Commented Jan 7, 2014 at 16:45
  • 1
    See if cdecl.org works on your phone :) Commented Jan 7, 2014 at 16:55

5 Answers 5

Reset to default
4

I have to do a[0][0] as if a was an array of arrays.

Indeed, a is a pointer to an array, so the array itself is *a, and the first element of the array would be (*a)[0] or, equivalently, a[0][0].

You probably want a to be a pointer to the first element of the array (just as c is a pointer to the first element of a dynamic array):

int * a = b;

and now a[i] will be element i of the array as expected.

Improve this answer
Sign up to request clarification or add additional context in comments.

1 Comment

@GeorgeRobinson: Yes. a[i] is equivalent to *(a+i), so a[0] is equivalent to *a.
1

a is a pointer to a single array, so you really should do (*a)[0]. And when you do a[0], that's the same thing as *a, so you get the array, which in the output decays to a pointer, which is why you see an address printed.

Whereas c is a pointer to an integer, and known to point to the first element of an array, so simple array notation works.

Improve this answer

Comments

1

The normal declaration of a would be 

int *a;

Then you could use

a = b;
std::cout << a[0];

Will print 

8
Improve this answer

1 Comment

So a is declared as a pointer to an integer which is assigned to the address of the element at index 0 of the array b. How can we then use the [0] on a pointer to an integer? Does the compiler perform integer arithmetic? std::cout << a + 0;
0

It is because you defined another type. Consider one more the statement

int* c = new int[3] { 2, 4, 6 };

In the left side you use int *c. So you could write the same for your local array

int *a;
int b[3] { 2, 4, 6 };
a = b;

In this case you could access each element of the array simply by using one subscripting:

a[0] = 8;

In this expression statement

a = b;

array b is implicitly converted to a pointer to its first element, that is subexpression b in the right side has type int *

Improve this answer

Comments

0

Declaration reflects use.

b is declared as int b[3]; you access (the first element of) it as b[0].

a is declared as int (*a)[3]; the equivalent access would be (*a)[0].

If you break down that "equivalent access", you can see that it has two operations. First, it uses the dereference operator "unary star" -- *a. a itself, remember, is a pointer. Dereferencing a returns the value pointed to. So once a = &b, then *a == b.

So what's the deal with a[0][0]? Well, the array access operator [] actually works on general pointers (and, to make things weirder, arrays "decay" to pointers). a[N] is defined in C to be exactly the same as *(a + N); so a[0] is the *a that we already discussed. Basically, using a[0][0] in this context instead of (*a)[0] is using a pun based on the definition of operator [] to hide that declaration should reflect use.

Improve this answer

Comments

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service and acknowledge you have read our privacy policy.