Thread: How Are C Arrays Represented In Memory?

I believe I understand how normal variables and pointers are represented in memory.

For example, it's easy to understand that a pointer Ptr will have one address, and its value will be a different address, which is the space in memory it's pointing to. The following code:

Code:

int main(){
	int x = 10;
	int *Ptr;
	Ptr = &x;
return 0;
}

Would have the following representation in memory:

Code:

+---------------------+-------------+---------+
| Variable Name       | Address     | Value   | 
+---------------------+-------------+---------+
| x                   | 3342        | 10      |
+---------------------+-------------+---------+
| Ptr                 | 5466        | 3342    |
+---------------------+-------------+---------+

However I find it difficult to understand how arrays are represented in memory. For example the code:

Code:

int main(){
	int x[5];
        x[0]=12;
        x[1]=13;
        x[1]=14;

	printf("%p\n",x);
	printf("%p\n",&x);

return 0;
}

outputs the same address twice (for the sake of simplicity 10568). Meaning that x==&x. Yet *x (or x[0] in array notation) is equal to 12, *(x+1) (or x[1] in array notation) is equal to 13 and so on. How can this be represented? One way could be this:

Code:

+---------------------+-------------+----------+----------------------+
| Variable Name       | Address     | Value    | Value IF array       |
+---------------------+-------------+----------+----------------------+
| x                   | 10568       | 10568    | 12                   |
+---------------------+-------------+----------+----------------------+
|                     | 10572       |          | 13                   | 
+---------------------+-------------+----------+----------------------+
|                     | 10576       |          | 14                   | 
+---------------------+-------------+----------+----------------------+

Is this close to what happens, or completely off?

An array will be stored contiguously in memory. In most contexts, an array will be converted to a pointer to its first element. Does your output make sense to you now?

Originally Posted by envec83

Code:

int main(){
	int x[5];
        x[0]=12;
        x[1]=13;
        x[1]=14;

	printf("%p\n",x);
	printf("%p\n",&x);

return 0;
}

outputs the same address twice (for the sake of simplicity 10568). Meaning that x==&x. Yet *x (or x[0] in array notation) is equal to 12, *(x+1) (or x[1] in array notation) is equal to 13 and so on. How can this be represented? One way could be this:

Code:

+---------------------+-------------+----------+----------------------+
| Variable Name       | Address     | Value    | Value IF array       |
+---------------------+-------------+----------+----------------------+
| x                   | 10568       | 10568    | 12                   |
+---------------------+-------------+----------+----------------------+
|                     | 10572       |          | 13                   | 
+---------------------+-------------+----------+----------------------+
|                     | 10576       |          | 14                   | 
+---------------------+-------------+----------+----------------------+

Is this close to what happens, or completely off?

:eyebrow:


Quzah.

Originally Posted by megafiddle

I get the same address for x and &x also.

How can the pointer x be stored at 10568 (for example), when x[0] is also stored at 10568?

Read the previous responses

Originally Posted by megafiddle

x is a pointer to address 10568, the 1st element of the array.

Address 10568 contans a 12.

x has the value 10568.

No, x is not a pointer. x is an array of 5 int elements, hence its value is the value of all the 5 int elements together.

Originally Posted by megafiddle

*x has the value 12.

Yes. At least conceptually, x was converted to a pointer to its first element, and then the result was dereferenced to get the first element, which has a value of 12.

Originally Posted by megafiddle

But if x is conceptually a pointer to the first element, what does &x mean?

The address of the array x, which is the same as the address of x's first element, except that the pointer type is different.

Originally Posted by megafiddle

So it's not like a pointer to a pointer, as in the case of passing the address of a pointer

No, it is like a pointer to a pointer, just like it is like a pointer to an int, or a pointer to a struct, etc.

Originally Posted by megafiddle

But isn't it pointing to itself?

Sigh, what points to itself? Compile and run this program:

Code:

#include <stdio.h>

int main(void)
{
    int x[] = {123, 456};
    int *p = x;
    ++p;
    printf("%d\n", *p);
    return 0;
}

Now, try to compile this program:

Code:

#include <stdio.h>

int main(void)
{
    int x[] = {123, 456};
    ++x;
    printf("%d\n", *x);
    return 0;
}

Now, tell me, if x is a pointer, why is it that the second program fails to compile, when what you did with x was exactly the same as what you did with the pointer p?

EDIT:
Here's another one to compile and run:

Code:

#include <stdio.h>

int main(void)
{
    int x[] = {123, 456, 789};
    int *p = x;
    printf("%u %u\n", sizeof(x), sizeof(p));
    return 0;
}

If both x and p are pointers, why does sizeof(x) differ from sizeof(p)?