Is an array's name a pointer in C? If not, what is the difference between an array's name and a pointer variable?
Is an array name a pointer?
An array is an array and a pointer is a pointer, but in most cases array names are converted to pointers. A term often used is that they decay to pointers.
Here is an array:
int a[7];
a contains space for seven integers, and you can put a value in one of them with an assignment, like this:
a[3] = 9;
Here is a pointer:
int *p;
p doesn't contain any spaces for integers, but it can point to a space for an integer. We can, for example, set it to point to one of the places in the array a, such as the first one:
p = &a[0];
What can be confusing is that you can also write this:
p = a;
This does not copy the contents of the array a into the pointer p (whatever that would mean). Instead, the array name a is converted to a pointer to its first element. So that assignment does the same as the previous one.
Now you can use p in a similar way to an array:
p[3] = 17;
The reason that this works is that the array dereferencing operator in C, [ ], is defined in terms of pointers. x[y] means: start with the pointer x, step y elements forward after what the pointer points to, and then take whatever is there. Using pointer arithmetic syntax, x[y] can also be written as *(x+y).
For this to work with a normal array, such as our a, the name a in a[3] must first be converted to a pointer (to the first element in a). Then we step 3 elements forward, and take whatever is there. In other words: take the element at position 3 in the array. (Which is the fourth element in the array, since the first one is numbered 0.)
So, in summary, array names in a C program are (in most cases) converted to pointers. One exception is when we use the sizeof operator on an array. If a was converted to a pointer in this context, sizeof a would give the size of a pointer and not of the actual array, which would be rather useless, so in that case a means the array itself.
A similar automatic conversion is applied to function pointers - both
functionpointer() and (*functionpointer)() mean the same thing, strangely enough. –
Kelcie He did not asked if arrays and pointers are the same, but if an array's name is a pointer –
Laina
An array name is not a pointer. It's an identifier for a variable of type array, which has an implicit conversion to pointer of element type. –
Divot
Also, apart from
sizeof(), the other context in which there's no array->pointer decay is operator & - in your example above, &a will be a pointer to an array of 7 int, not a pointer to a single int; that is, its type will be int(*)[7], which is not implicitly convertible to int*. This way, functions can actually take pointers to arrays of specific size, and enforce the restriction via the type system. –
Divot @Pavel: Thanks for the comment about &. I knew there were other exceptions, but sizeof was the only one on top of my mind. I've changed "an exception" to "one exception", which I think indicates that there are other exceptions (but I'm no a native English speaker). –
Turmoil
to be fair, asking for the difference of an array's name in expressions to the name of a pointer is not asking whether arrays are different from pointers. Example: In C++, a reference's name in expressions is the same as the referenced object's name in expressions. Still, a reference is not the same as the object it references. But instead, while evaluating, the reference type is replaced by the referenced type, and is an lvalue. In C, somewhat similar happens with arrays, just that this conversion doesn't always happen: Not in sizeof and address-of: These are operators not applied to values –
Iridium
Note that this automatic conversion doesn't happen in C++. In C++, it happens only when needed (for example when assigning to a pointer), whereas in C, the array to pointer conversion always happens if not within sizeof or address-of or initializing an array with a string literal. –
Iridium
@CarlNorum Interesting, do you have any document for it –
Psychochemical
@onmyway133, check here for a short explanation and further citations. –
Kelcie
Another situation the conversion does not happen is when the array is the operand of
++ or -- –
Airborne @M.M: I'm not sure what you mean there? It's true that there will be no conversion when doing
char a[7]; a++;, but that's because it's an error. –
Turmoil @SurajJain: To start with, what would
a=something mean? Changing the content of the array? That's how normal (non-array) variables work in C, and how arrays work in many other languages, but the designers of C decided to make arrays a kind of second class citizens, so they can't be assigned directly in that way. –
Turmoil @ThomasPadron-McCarthy , ok Thanks , i have another thing to ask is this valid printf("%d" ,
a) ,?? I am asking this in reference to this question stackoverflow.com/questions/34826036/… –
Submergible @SurajJain: No, in
printf("%d" , a) you are telling printf that you are sending it an integer, but instead you are sending it a pointer (pointing to the first element in the array). You can do printf("%p" , (void*)a) to print the pointer. –
Turmoil oh, sorry i forget to include 'a' what mean is does printf("%d" , 'a') correct ? using %d for char , as char are default promoted to int , this answer says you cannot but other seem to say that you can , i am confused stackoverflow.com/questions/34826036/… –
Submergible
As far as I know,
printf("%d" , 'a') is allowed, which would make that answer incorrect in that detail. 'a' will be promoted to integer, so that is not a problem. But sometimes there are rather surprising constraints on what the standard guarantees will work on all conforming platforms, and without further study I'm not going to promise anything. –
Turmoil Is it possible to get the same sizeof(a) behavior, considering 'a' as an array, but in a function parameter? MyFunc(int b[]) sizeof(b) will be wrong. –
Restivo
@Pedro77: Inside the function,
b is just a pointer, so you need to send the length information some other way. You can add a parameter for the length, or have a special end value in the array like in the C string functions. –
Turmoil I ended up here after hours of confusion about why wont int** i = new int[3] work ... this post helps a lot ! –
Arduous
(To avoid confusion on @PavelMinaev's comment above) It would make more sense to compare
int(*)[7] with int**(not just int*). I.e., if I rewrite his comment, it would be: "in your example above, &a will be an address to 'an array of 7 int', not an address to 'a pointer to a single int'; that is, its type will be int(*)[7], which is not implicitly convertible to int**." –
Cimbalom When an array is used as a value, its name represents the address of the first element.
When an array is not used as a value its name represents the whole array.
int arr[7];
/* arr used as value */
foo(arr);
int x = *(arr + 1); /* same as arr[1] */
/* arr not used as value */
size_t bytes = sizeof arr;
void *q = &arr; /* void pointers are compatible with pointers to any object */
If an expression of array type (such as the array name) appears in a larger expression and it isn't the operand of either the & or sizeof operators, then the type of the array expression is converted from "N-element array of T" to "pointer to T", and the value of the expression is the address of the first element in the array.
In short, the array name is not a pointer, but in most contexts it is treated as though it were a pointer.
Edit
Answering the question in the comment:
If I use sizeof, do i count the size of only the elements of the array? Then the array “head” also takes up space with the information about length and a pointer (and this means that it takes more space, than a normal pointer would)?
When you create an array, the only space that's allocated is the space for the elements themselves; no storage is materialized for a separate pointer or any metadata. Given
char a[10];
what you get in memory is
+---+
a: | | a[0]
+---+
| | a[1]
+---+
| | a[2]
+---+
...
+---+
| | a[9]
+---+
The expression a refers to the entire array, but there's no object a separate from the array elements themselves. Thus, sizeof a gives you the size (in bytes) of the entire array. The expression &a gives you the address of the array, which is the same as the address of the first element. The difference between &a and &a[0] is the type of the result1 - char (*)[10] in the first case and char * in the second.
Where things get weird is when you want to access individual elements - the expression a[i] is defined as the result of *(a + i) - given an address value a, offset i elements (not bytes) from that address and dereference the result.
The problem is that a isn't a pointer or an address - it's the entire array object. Thus, the rule in C that whenever the compiler sees an expression of array type (such as a, which has type char [10]) and that expression isn't the operand of the sizeof or unary & operators, the type of that expression is converted ("decays") to a pointer type (char *), and the value of the expression is the address of the first element of the array. Therefore, the expression a has the same type and value as the expression &a[0] (and by extension, the expression *a has the same type and value as the expression a[0]).
C was derived from an earlier language called B, and in B a was a separate pointer object from the array elements a[0], a[1], etc. Ritchie wanted to keep B's array semantics, but he didn't want to mess with storing the separate pointer object. So he got rid of it. Instead, the compiler will convert array expressions to pointer expressions during translation as necessary.
Remember that I said arrays don't store any metadata about their size. As soon as that array expression "decays" to a pointer, all you have is a pointer to a single element. That element may be the first of a sequence of elements, or it may be a single object. There's no way to know based on the pointer itself.
When you pass an array expression to a function, all the function receives is a pointer to the first element - it has no idea how big the array is (this is why the gets function was such a menace and was eventually removed from the library). For the function to know how many elements the array has, you must either use a sentinel value (such as the 0 terminator in C strings) or you must pass the number of elements as a separate parameter.
- Which *may* affect how the address value is interpreted - depends on the machine.
Have been looking for quite a long time for this answer. Thank you! And if you know, could you tell a little further what an array expression is. If I use sizeof, do i count the size of only the elements of the array? Then the array “head” also takes up space with the information about length and a pointer (and this means that it takes more space, than a normal pointer would)? –
Reluctant
And one more thing. An array of length 5 is of type int[5]. So that is from where we know the length when we call sizeof(array) - from its type? And this means that arrays of different length are like different types of constants? –
Reluctant
@AndriyDmytruk:
sizeof is an operator, and it evaluates to the number bytes in the operand (either an expression denoting an object, or a type name in parentheses). So, for an array, sizeof evaluates to the number of elements multiplied by the number of bytes in a single element. If an int is 4 bytes wide, then a 5-element array of int takes up 20 bytes. –
Thay Isn't the operator
[ ] special too? For example, int a[2][3];, then for x = a[1][2];, though it can be rewritten as x = *( *(a+1) + 2 );, here a isn't converted to a pointer type int* (though if a is an argument of a function it should be converted to int*). –
Uthrop @Stan: The subscript operation
a[i] is defined as *(a + i) - given a starting address a, find the address of the i'th object in the array, and dereference the result. If a is an expression of array type, it will be converted to a pointer before the addition is performed. Remember that in pointer arithmetic, a + 1 yields the address of the next object of the pointed to type, not the next byte. If a points to a 4-byte int, then a + 1 points to the next 4-byte int. If a points to a 128-byte struct, then a + 1 points to the next 128-byte struct. –
Thay Sorry I didn't express it clearly. Yes, your explanation can be consistent, but I just think it easily confusing and can't reflect the ASM operations. If I didn't misunderstand, for my very example
int a[2][3]; and then x = *( *(a+1) + 2 );, we are indeed able to interpret that a is first converted to the pointer type int (*)[3] so that a+1 moves forward sizeof(int [3]), and then *(a+1) dereferences the pointer int (*)[3] to the pointer int*, and then in the whole *( *(a+1) + 2 ) the int* pointer *(a+1) moves 2*sizeof(int) forward and is dereferenced to an int. –
Uthrop ... though the above explanation is semantically correct, there aren't two dereference operations in the actual machine code. So, it might not be a good explanation. –
Uthrop
@Stan: The expression
a has type int [2][3], which "decays" to type int (*)[3]. The expression *(a + 1) has type int [3], which "decays" to int *. Thus, *(*(a + 1) + 2) will have type int. a points to the first 3-element array of int, a + 1 points to the second 3-element array of int, *(a + 1) is the second 3-element array of int, *(a + 1) + 2 points to the third element of the second array of int, so *(*(a + 1) + 2) is the third element of the second array of int. How that gets mapped to machine code is entirely up to the compiler. –
Thay @JohnBode thanks for the detailed reply! But not “entirely up to the compiler” because the standard currently requires “contiguous allocated” (6.2.5 Types) for arrays, and in de facto implementations, I haven’t seen any compiler uses two dereferences for that 2D array. I guess the advantage for the “standardized” (though not really) memory layout of array could help design flexible function interface, e.g.
void f(int* matrix, int rowNum, int columnNum) can adapt 2D arrays with different sizes. –
Uthrop I read the answer, and I want to clear something. The statement-As soon as that array expression "decays" to a pointer, all you have is a pointer to a single element. So,it means that some memory space(other than the memory spaces already allocated for the array elements) is being allocated for a pointer to store the base address of the array right? –
Mutation
if it doesn't decay when
& why did you say &a[0] have the same value of a which is *a if you know what I mean –
Rayner @Paralax01:
*a == a[0] // char == char, a == &a[0] // char * == char *. &a will yield the same address value as a or &a[0], but will have a different type - char (*)[10] - and may possibly be represented differently. –
Thay An array declared like this
int a[10];
allocates memory for 10 ints. You can't modify a but you can do pointer arithmetic with a.
A pointer like this allocates memory for just the pointer p:
int *p;
It doesn't allocate any ints. You can modify it:
p = a;
and use array subscripts as you can with a:
p[2] = 5;
a[2] = 5; // same
*(p+2) = 5; // same effect
*(a+2) = 5; // same effect
Arrays are not always allocated on the stack. Yhat's an implementation detail that will vary from compiler to compiler. In most cases static or global arrays will be allocated from a different memory region than the stack. Arrays of const types may be allocated from yet another region of memory –
Mullite
I think Grumdrig meant to say "allocates 10
ints with automatic storage duration`. –
Variegate The array name by itself yields a memory location, so you can treat the array name like a pointer:
int a[7];
a[0] = 1976;
a[1] = 1984;
printf("memory location of a: %p", a);
printf("value at memory location %p is %d", a, *a);
And other nifty stuff you can do to pointer (e.g. adding/substracting an offset), you can also do to an array:
printf("value at memory location %p is %d", a + 1, *(a + 1));
Language-wise, if C didn't expose the array as just some sort of "pointer"(pedantically it's just a memory location. It cannot point to arbitrary location in memory, nor can be controlled by the programmer). We always need to code this:
printf("value at memory location %p is %d", &a[1], a[1]);
Doesn't this code cause UB when
sizeof (int*) != sizeof (void*)? To be fair, i don't know any system where this is the case. –
Traps @Traps it's UB on all systems (due to mismatched format specifier), but more likely to give unexpected output on systems as you describe –
Airborne
I think this example sheds some light on the issue:
#include <stdio.h>
int main()
{
int a[3] = {9, 10, 11};
int **b = &a;
printf("a == &a: %d\n", a == b);
return 0;
}
It compiles fine (with 2 warnings) in gcc 4.9.2, and prints the following:
a == &a: 1
oops :-)
So, the conclusion is no, the array is not a pointer, it is not stored in memory (not even read-only one) as a pointer, even though it looks like it is, since you can obtain its address with the & operator. But - oops - that operator does not work :-)), either way, you've been warned:
p.c: In function ‘main’:
pp.c:6:12: warning: initialization from incompatible pointer type
int **b = &a;
^
p.c:8:28: warning: comparison of distinct pointer types lacks a cast
printf("a == &a: %d\n", a == b);
C++ refuses any such attempts with errors in compile-time.
Edit:
This is what I meant to demonstrate:
#include <stdio.h>
int main()
{
int a[3] = {9, 10, 11};
void *c = a;
void *b = &a;
void *d = &c;
printf("a == &a: %d\n", a == b);
printf("c == &c: %d\n", c == d);
return 0;
}
Even though c and a "point" to the same memory, you can obtain address of the c pointer, but you cannot obtain the address of the a pointer.
"It compiles fine (with 2 warnings)". That's not fine. If you tell gcc to compile it as proper standard C by adding
-std=c11 -pedantic-errors, you get a compiler error for writing invalid C code. The reason why is because you try to assign a int (*)[3] to a variable of int**, which are two types that have absolutely nothing to do with each other. So what this example is supposed to prove, I have no idea. –
Nuri Thank you Lundin for your comment. You know there are many standards. I tried to clarify what I meant in the edit. The
int ** type is not the point there, one should better use the void * for this. –
Philine The following example provides a concrete difference between an array name and a pointer. Let say that you want to represent a 1D line with some given maximum dimension, you could do it either with an array or a pointer:
typedef struct {
int length;
int line_as_array[1000];
int* line_as_pointer;
} Line;
Now let's look at the behavior of the following code:
void do_something_with_line(Line line) {
line.line_as_pointer[0] = 0;
line.line_as_array[0] = 0;
}
void main() {
Line my_line;
my_line.length = 20;
my_line.line_as_pointer = (int*) calloc(my_line.length, sizeof(int));
my_line.line_as_pointer[0] = 10;
my_line.line_as_array[0] = 10;
do_something_with_line(my_line);
printf("%d %d\n", my_line.line_as_pointer[0], my_line.line_as_array[0]);
};
This code will output:
0 10
That is because in the function call to do_something_with_line the object was copied so:
- The pointer
line_as_pointerstill contains the same address it was pointing to - The array
line_as_arraywas copied to a new address which does not outlive the scope of the function
So while arrays are not given by values when you directly input them to functions, when you encapsulate them in structs they are given by value (i.e. copied) which outlines here a major difference in behavior compared to the implementation using pointers.
NO. An array name is NOT a pointer. You cannot assign to or modify an array name, but you can for a pointer.
int arr[5];
int *ptr;
/* CAN assign or increment ptr */
ptr = arr;
ptr++;
/* CANNOT assign or increment arr */
arr = ptr;
arr++;
/* These assignments are also illegal */
arr = anotherarray;
arr = 0;
From K&R Book:
There is one difference between an array name and a pointer that must be kept in mind. A pointer is a variable, but an array name is not a variable.
sizeof is the other big difference.
sizeof(arr); /* size of the entire array */
sizeof(ptr); /* size of the memory address */
Arrays do behave like or decay into a pointer in some situations (&arr[0]). You can see other answers for more examples of this. To reiterate a few of these cases:
void func(int *arr) { }
void func2(int arr[]) { } /* same as func */
ptr = arr + 1; /* pointer arithmetic */
func(arr); /* passing to function */
Even though you cannot assign or modify the array name, of course can modify the contents of the array
arr[0] = 1;
Here is how I understood the differences (and the similarities) between arrays and pointers.
int v = 0;
| |
|-------|
100 | | Name 1 - v
| 0 | Name 2 - *100
| |
103 | |
|-------|
| |
Even though *100 is technically not a name, and is instead a unary operator
(i.e. *) along with its operand (i.e. 100), we can still think of it as a name
in order to understand how addresses/pointers work.
Now, &v means the starting address of the variable whose name is v (i.e. 100).
Also, the data type of 100 is int* (i.e. pointer-to-int).
1. printf("%d\n", v)
is equivalent to printf("%d\n", 0)
is equivalent to printf("%d\n", *100)
2. v = 10
is equivalent to *100 = 10
3. v + 1
is equivalent to 0 + 1
is equivalent to *100 + 1
4. scanf("%d", &v)
is equivalent to scanf("%d", &(*100))
is equivalent to scanf("%d", 100)
5. func(&v)
is equivalent to func(&(*100))
is equivalent to func(100)
and so on.
Since the data type of 10 is int, therefore it can be assigned to the variable
whose name is v because that variable's data type is also int.
Similarly, since the data type of 100 is int* (i.e. pointer-to-int), therefore
it can be assigned to a variable whose data type is also int*.
////////////////////////////////////////////////////////////////////////////////
int* ptr = &v; is equivalent to int* ptr = 100;
| |
|-------|
100 | | Name 1 - v
| 0 | Name 2 - *100
| |
103 | |
|-------|
| |
| |
|-------|
200 | | Name 1 - ptr
| | Name 2 - *200
| |
| 100 |
| |
| |
| |
207 | |
|-------|
| |
Now, for eg., when evaluating v + 1, v is equivalent to 0 because 0 is the value
which is stored in the variable whose name is v.
Similarly, when evaluating *ptr, ptr is equivalent to 100 because 100 is the
value which is stored in the variable whose name is ptr.
1. printf("%d\n", v)
is equivalent to printf("%d\n", 0)
is equivalent to printf("%d\n", *100)
is equivalent to printf("%d\n", *ptr)
2. v = 10
is equivalent to *100 = 10
is equivalent to *ptr = 10
3. v + 1
is equivlent to 0 + 1
is equivalent to *100 + 1
is equivalent to *ptr + 1
4. scanf("%d", &v)
is equivalent to scanf("%d", &(*100))
is equivalent to scanf("%d", 100)
is equivalent to scanf("%d", &(*ptr))
is equivalent to scanf("%d", ptr)
5. func(&v)
is equivalent to func(&(*100))
is equivalent to func(100)
is equivalent to func(&(*ptr))
is equivalent to func(ptr)
and so on.
So, we can also think that the variable whose name is v gets a third name, i.e.
*ptr.
| |
|-------|
100 | | Name 1 - v
| 0 | Name 2 - *100
| | Name 3 - *ptr
103 | |
|-------|
| |
Also, to get the address of this variable, we can use &v, 100 or ptr.
////////////////////////////////////////////////////////////////////////////////
int main(void)
{
int v;
...
func(&v);
...
}
void func(int* ptr)
{
...
*ptr = 5;
...
}
Here, the function call func(&v) is equivalent to func(100).
So, when func() is executed, the name v of the variable which is local to main()
goes out of scope.
| |
|-------|
100 | | Name 1 - xxxx
| 0 | Name 2 - *100
| |
103 | |
|-------|
| |
Now, a variable which is local to func() whose name is ptr and whose data type
is pointer-to-int is created.
| |
|-------|
200 | | Name 1 - ptr
| | Name 2 - *200
| |
| 100 |
| |
| |
| |
207 | |
|-------|
| |
Now, the variable which is local to main() gets a new name.
| |
|-------|
100 | | Name 1 - xxxx
| 0 | Name 2 - *100
| | Name 3 - *ptr
103 | |
|-------|
| |
And, to get the address of the variable local to main(), we can use 100 or ptr.
After executing *ptr = 5, when func() returns, the variable which is local to
func() and whose name is ptr is destroyed, and the name v of the variable which
is local to main() is restored.
Also, since the variable which is local to func() and whose name is ptr is
destroyed, therefore the name *ptr of the variable which is local to main() is
also destroyed.
| |
|-------|
100 | | Name 1 - v
| 5 | Name 2 - *100
| |
103 | |
|-------|
| |
////////////////////////////////////////////////////////////////////////////////
int arr[3] = {7, 8, 9};
arr is the name of the entire array.
| |
|-------|
300 | | Name - *300
| 7 |
| |
303 | |
|-------|
304 | | Name - *304
| 8 |
| |
307 | |
|-------|
308 | | Name - *308
| 9 |
| |
311 | |
|-------|
| |
When the expression v + 1.0 is evaluated, the data type of v is converted from
int to double only for the purpose of evaluating that expression.
Similarly, except for those 4 cases (&, sizeof, alignof, string literal used to
initialize an array), arr is converted to the address of the first element of
the array only for the purpose of evaluating the corresponding expression.
Also, for eg., if the array consists of elements of data type int, then the
data type of the resultant address is pointer-to-int. So, the resultant address
can be assigned to a variable of data type pointer-to-int.
For eg., int* ptr = arr;
So, in other words, except for those 4 cases, arr is converted to a pointer to
the first element of the array only for the purpose of evaluating the
corresponding expression.
When an integer is added to an address/pointer, the resultant address is
calculated according to the data type of the address/pointer.
For eg., 300 + 1 gives 304.
arr[i] is equivalent to *(arr + i).
Now, arr[1]
is equivalent to *(arr + 1)
is equivalent to *(300 + 1)
is equivalent to *304
And, &(arr[1])
is equivalent to &(*(arr + 1))
is equivalent to &(*(300 + 1))
is equivalent to &(*304)
is equivalent to 304
Also, arr + 1
is equivalent to 300 + 1
is equivalent to 304
1. printf("%d\n", arr[1])
is equivalent to printf("%d\n", 8)
is equivalent to printf("%d\n", *(arr + 1))
is equivalent to printf("%d\n", *304)
2. arr[1] = 10
is equivalent to *(arr + 1) = 10
is equivalent to *304 = 10
3. arr[1] + 1
is equivalent to 8 + 1
is equivalent to *(arr + 1) + 1
is equivalent to *304 + 1
4. scanf("%d", &(arr[1]))
is equivalent to scanf("%d", &(*(arr + 1)))
is equivalent to scanf("%d", &(*304))
is equivalent to scanf("%d", 304)
is equivalent to scanf("%d", arr + 1)
5. func(&(arr[1]))
is equivalent to func(&(*(arr + 1)))
is equivalent to func(&(*304))
is equivalent to func(304)
is equivalent to func(arr + 1)
and so on.
So, we can also think that the elements of the array have other names.
| |
|-------|
300 | | Name 1 - *300
| 7 | Name 2 - arr[0]
| | Name 3 - *(arr + 0)
303 | |
|-------|
304 | | Name 1 - *304
| 8 | Name 2 - arr[1]
| | Name 3 - *(arr + 1)
307 | |
|-------|
308 | | Name 1 - *308
| 9 | Name 2 - arr[2]
| | Name 3 - *(arr + 2)
311 | |
|-------|
| |
Also, to get the address of, for eg., arr[1], we can use &(arr[1]), 304 or
arr + 1.
////////////////////////////////////////////////////////////////////////////////
int main(void)
{
int arr[3];
...
func(arr);
...
}
void func(int* arr)
{
...
arr[1] = 6;
...
}
Here, the function call func(arr) is equivalent to func(300).
So, when func() is executed, the name arr of the entire array which is local to
main() goes out of scope, which means that Name 2 and Name 3 of every element of
the array also go out of scope.
| |
|-------|
300 | | Name 1 - *300
| 7 | Name 2 - xxxx
| | Name 3 - xxxx
303 | |
|-------|
304 | | Name 1 - *304
| 8 | Name 2 - xxxx
| | Name 3 - xxxx
307 | |
|-------|
308 | | Name 1 - *308
| 9 | Name 2 - xxxx
| | Name 3 - xxxx
311 | |
|-------|
| |
Now, a variable which is local to func() whose name is arr and whose data type
is pointer-to-int is created.
| |
|-------|
400 | | Name 1 - arr
| | Name 2 - *400
| |
| 300 |
| |
| |
| |
407 | |
|-------|
| |
It should be noted that when the expression arr[1] = 6 is evaluated inside
func(), arr isn't the name of the array which is local to main(), and is instead
the name of the variable which is local to func().
So, there is no need to convert arr to a pointer, as arr is already a pointer.
Now, similar to main(), inside func() also
arr[1]
is equivalent to *(arr + 1)
is equivalent to *(300 + 1)
is equivalent to *304
And, &(arr[1])
is equivalent to &(*(arr + 1))
is equivalent to &(*(300 + 1))
is equivalent to &(*304)
is equivalent to 304
Also, arr + 1
is equivalent to 300 + 1
is equivalent to 304
So, the elements of the array which is local to main() get new names.
| |
|-------|
300 | | Name 1 - *300
| | Name 2 - xxxx
| 7 | Name 3 - xxxx
| | Name 4 - arr[0]
303 | | Name 5 - *(arr + 0)
|-------|
304 | | Name 1 - *304
| | Name 2 - xxxx
| 8 | Name 3 - xxxx
| | Name 4 - arr[1]
307 | | Name 5 - *(arr + 1)
|-------|
308 | | Name 1 - *308
| | Name 2 - xxxx
| 9 | Name 3 - xxxx
| | Name 4 - arr[2]
311 | | Name 5 - *(arr + 2)
|-------|
| |
And, to get the address of, for eg., arr[1], we can use &(arr[1]), 304 or
arr + 1.
After executing arr[1] = 6, when func() returns, the variable which is local to
func() and whose name is arr is destroyed, and the name arr of the entire array
which is local to main() is restored, which means that Name 2 and Name 3 of
every element of the array are also restored.
Also, since the variable which is local to func() and whose name is arr is
destroyed, therefore Name 4 and Name 5 of every element of the array are also
destroyed.
| |
|-------|
300 | | Name 1 - *300
| 7 | Name 2 - arr[0]
| | Name 3 - *(arr + 0)
303 | |
|-------|
304 | | Name 1 - *304
| 6 | Name 2 - arr[1]
| | Name 3 - *(arr + 1)
307 | |
|-------|
308 | | Name 1 - *308
| 9 | Name 2 - arr[2]
| | Name 3 - *(arr + 2)
311 | |
|-------|
| |
The array name behaves like a pointer and points to the first element of the array. Example:
int a[]={1,2,3};
printf("%p\n",a); //result is similar to 0x7fff6fe40bc0
printf("%p\n",&a[0]); //result is similar to 0x7fff6fe40bc0
Both the print statements will give exactly same output for a machine. In my system it gave:
0x7fff6fe40bc0
© 2022 - 2024 — McMap. All rights reserved.
&array[0]yields a pointer, not an array ;) – Arraignment