An array is a queue of values, all stored as one compact unit with a handy reference method. As you study arrays, especially when you get into pointers, you discover something interesting about the array’s first element.
\n
\nSpecifically, you find out that the array’s address — its location in memory — is the same as the address of the first element. For some reason this relationship causes massive confusion, maybe even convulsions.<\/p>\n
To review, take your typical array. In this case, I’m concocting an integer array named The Lines 7 and 8 in the code display the address of As you can see, both addresses are the same. The start of the array itself is at memory location That location makes sense to me. After all, the array starts at the first element. Why would its location be elsewhere?<\/p>\n What I believe is throwing some readers is that the two items being referenced are not the same. In this case, See how the The output is the same. Again, that’s because But what about That’s a different creature: The variable The variables In the grand scheme of things, the array’s first element, The first element of an array holds the same address as the array itself. So what’s the difference? Continue reading doris<\/code>, as shown in the following code:<\/p>\n\r\n#include <stdio.h>\r\n\r\nint main()\r\n{\r\n int doris[] = { 2, 3, 5, 8, 13 };\r\n\r\n printf(\"%p array address\\n\",&doris);\r\n printf(\"%p first element\\n\",&doris[0]);\r\n\r\n return(0);\r\n}<\/pre>\ndoris<\/code> array has five elements. They’re stored in memory, one after the other, each given their own specific address and a proper number of bytes according to the sizeof<\/em> an integer on whatever gizmo the code is compiled.<\/p>\ndoris<\/code> itself (herself?) as well as the address of the array’s first element, doris[0]<\/code>. Here’s the output on my computer:<\/p>\n0x7fff59a7fa94 array address\r\n0x7fff59a7fa94 first element<\/code><\/pre>\n...fa94<\/code> and the first element is at ...fa94<\/code>. Identical.<\/p>\ndoris<\/code> is an array. The compiler actually recognizes it as a memory location, a pointer. The array notation is merely window dressing. In fact, you can change Line 7 in the code to read as follows:<\/p>\nprintf(\"%p array address\\n\",doris);<\/code><\/p>\n&<\/code> is missing before the variable doris<\/code>?<\/p>\ndoris<\/code> is really a pointer. The compiler sees the &<\/code> unary operator there, shrugs its shoulders, and says “Meh.” The &<\/code> is superfluous. You don’t see an error message, which may be confusing, because there is no error. Both &doris<\/code> and doris<\/code> are an address. The &<\/code> operator doesn’t get “the address of an address” because there is no such thing.<\/p>\n&doris[0]<\/code>?<\/p>\ndoris<\/code> is a pointer. The variable doris[0]<\/code> is an int<\/em>.<\/p>\ndoris[1]<\/code>, doris[2]<\/code>, doris[3]<\/code>, and doris[4]<\/code> are also ints<\/em>. They are not pointers. They hold integer values, not memory locations (addresses). Therefore, to fetch the address of any array element, you definitely need the &<\/code> unary operator.<\/p>\ndoris[0]<\/code> (which is an int<\/em> value), is located as the same address as doris<\/code>, the start of the array. Therefore, generically speaking, the memory location stored in array<\/code> is always the same as the address of array[0]<\/code>, which is coded as &array[0]<\/code>.<\/p>\n","protected":false},"excerpt":{"rendered":"