Multidimensional arrays memory storage overview

Question

Lately I started learning pointers and references in c++ (not just the usual use of them,but all kinds of ways,I don't want to have problems with them in near future).

From my perspective a 1d static allocated array is similar to a int* const pointer. My problem is that ,when I allocate dynamically with a pointer, the pointer itself has other memory address than the first element,which is not the case in a 1d array. This is an example

int a[5];
cout<<&a<<" "<<&a[0]<<"\n";
int* t=new int[10];
cout<<&t<<" "<<&t[0]<<"\n";

The output is:

0x6afed0 0x6afed0
0x6afecc 0xcb0e40

I can't think how the 1d array is stored,at 1 block of 4 bytes you can store either a value or an address. I tried also with 2d arrays,and there are more intersections.

q = new int*[10];
for (i=0;i<10;i++)
    q[i] = new int[i+1];
cout<<&q<<" "<<&q[0]<<" "<<&q[0][0]<<"\n";
int b[10][10];
cout<<&b<<" "<<&b[0]<<" "<<&b[0][0]<<"\n";

Output:

0x6afee4 0xe40e40 0xe41240
0x6afd54 0x6afd54 0x6afd54

If someone would enlighten me and explain how these arrays are stored,I would be thankful.

EDIT:To be more specific, I know and it's logical how the array dynamically created with new keyword by the pointer is stored. But how &a and &a[0] have the same values,if a should store the address of a[0] .That block of memory(&a) stores what then?the value of a[0] or the address of a[0]. Hope I was clear in what my problem is.

See this answer of mine: http://stackoverflow.com/questions/23581342/difference-between-2d-char-array-and-char-or-3d-char-array-and-char-etc/23582916#23582916 — HolyBlackCat, Apr 06 '16 at 16:45
Thank you for your answer. But as arnobpl said, you get confused because you can use * on an array name like a pointer, so you think they are the same (which they aren't). — Baltatu Andrei Mircea, Apr 06 '16 at 17:06
I understand that they are not the same, I have not said otherwise. Maybe my answer was not entirely clear though. — HolyBlackCat, Apr 06 '16 at 17:10
Sorry,when I said "you" ,I meant a human in general, not you:P — Baltatu Andrei Mircea, Apr 06 '16 at 17:19

Aadil Bhatti · Answer 1 · 2016-04-07T14:18:29.230

t is a pointer declared on the stack which holds the address of an array on the heap. &t gets the address of t, AKA the location of t on the stack. If you want to access the first member of the array, you can either do *t or t[0]. C++ automatically dereferences and does pointer arithmetic based on the type of t when you use the bracket notation.

However, &t[0] essentially gets you the address of t[0], which is why it is different from &t, as &t lives on the stack while &t[0] lives on the heap. So if you want the address of t[0], you can use that notation, otherwise stick to t[0] if you just want the values.

score 1 · Answer 2 · answered Apr 06 '16 at 16:51

1

An array is an object that contains a contiguous block of N objects where N is some constant size. The address of the array is the start of the array so the address of the first object and the addresss of the array are the same thing.

A pointer to an array is a unique object. Since it is it's own object it has its own address separate from the address that it holds. so with int* t=new int[10]; &t is the address of t where &t[0] is the address of the first element of the array that was allocated by new.

answered Apr 06 '16 at 16:51

NathanOliver

171,901
28
288
402

So actually a static declared array is not a pointer?(even if you can do *(a+i) or p=a where p is a pointer). I thought *x tells the compiler "give me what is stored in the address that x contains" so *a should give a wrong answer if &a=&a[0]. So i should treat them separetely as 2 distinct things? – Baltatu Andrei Mircea Apr 06 '16 at 16:55
1

@BaltatuAndreiMircea An array is not a pointer. They are two completely different things. Unfortunately an array can decay into a pointer in a number of cases so it is easy to get them confused. `*a` is the same as `*(a + 0)` which is the same as `a[0]`. Fun right? – NathanOliver Apr 06 '16 at 16:57

score 1 · Answer 3 · edited Jun 20 '20 at 09:12

Arrays are first-class entities of the language, so when you declare an array variable

int a[10];

the compiler knows the dimensions of the array. When you allocate a dynamic storage space

int* p = new int[10];

Only you and the allocator know how large this space is.

In the array version, a is the array. It has an address, but that address is held by the compiler during compilation. In the allocation pardigm, p is the address of the data, which won't be known until run time.

What causes people to be confused is that by and large the two seem interchangeable: you can do pointer and array math with both, use either where a pointer is expected:

void f(int*);

int a1 = a[1];
f(a);
int p1 = p[1];
f(p);

This is by design, it's something called array-pointer-equivalence, emphasis mine:

Much of the confusion surrounding arrays and pointers in C can be traced to a misunderstanding of this statement. Saying that arrays and pointers are ''equivalent'' means neither that they are identical nor even interchangeable. What it means is that array and pointer arithmetic is defined such that a pointer can be conveniently used to access an array or to simulate an array. In other words, as Wayne Throop has put it, it's ''pointer arithmetic and array indexing [that] are equivalent in C, pointers and arrays are different.'')

Specifically, the cornerstone of the equivalence is this key definition:

A reference to an object of type array-of-T which appears in an expression decays (with three exceptions) into a pointer to its first element; the type of the resultant pointer is pointer-to-T.

Very thorough answer,thank you very much. So because the address and size of static declared arrays are known at compile time(in most of the cases,because with the new compilers,you can do int a[x] with x an int variable), when decaying to a pointer and losing a dimension it still forces that pointer to have the right boundaries to other dimensions . As with pointers,or pointers to pointers,it can't set anything because things can change at run-time.I got it ,thanks again! — Baltatu Andrei Mircea, Apr 06 '16 at 23:09

score 0 · Answer 4 · answered Apr 06 '16 at 16:46

0

&t is taking the address of the pointer t, not the address of the first element. The address of the first element is just t (as t is an int*, which points to the block of memory).

answered Apr 06 '16 at 16:46

Rakete1111

47,013
16
123
162

Multidimensional arrays memory storage overview

4 Answers4

Linked

Related