blocks|key|1764246|text|这至少提供了一个清晰的编译，并使用%25p打印指针：|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1764247|#include+<stdio.h>

int+main(void)
{
++++int+p[5]={2,3,5,6,8};
++++int+*x+=+p;
++++int+**y+=+&x;
++++printf("p+value+is+%25p+and+the+address+of+p+is+%25p+and+p+points+to+%25d\n",+(void+*)p,+(void+*)&p,+*p);
++++printf("x[1]+is+%25d\n",+x[1]);
++++printf("y[0]+is+the+address+%25p\n",+(void+*)y[0]);
++++printf("y[0][0]+is+%25d\n",+y[0][0]);

++++return+0;
}|code-block|syntax|javascript|1764248|示例输出(Mac+10.8.4，GCC+4.8.1，64位编译)：|1764249|p+value+is+0x7fff5a1a54d0+and+the+address+of+p+is+0x7fff5a1a54d0+and+p+points+to+2
x[1]+is+3
y[0]+is+the+address+0x7fff5a1a54d0
y[0][0]+is+2|1764250|entityMap^0|H|2|0|0|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@$9|R|A|S|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|T|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|U|8|@]|D|@]|E|$]]|$1|M|3|N|5|H|7|V|8|@]|D|@]|E|$I|J]]|$1|O|3|-4|5|6|7|W|8|@]|D|@]|E|$]]]|P|$]]

This at least gives a clean compilation and uses <code>%p</code> to print pointers:

<pre><code>#include &lt;stdio.h&gt;

int main(void)
{
 int p[5]={2,3,5,6,8};
 int *x = p;
 int **y = &amp;x;
 printf("p value is %p and the address of p is %p and p points to %d\n", (void *)p, (void *)&amp;p, *p);
 printf("x[1] is %d\n", x[1]);
 printf("y[0] is the address %p\n", (void *)y[0]);
 printf("y[0][0] is %d\n", y[0][0]);

 return 0;
}
</code></pre>

Sample output (Mac OS X 10.8.4, GCC 4.8.1, 64-bit compilation):

<pre><code>p value is 0x7fff5a1a54d0 and the address of p is 0x7fff5a1a54d0 and p points to 2
x[1] is 3
y[0] is the address 0x7fff5a1a54d0
y[0][0] is 2
</code></pre>

blocks|key|688042|text|记住，数组名称在大多数表达式中很容易变成指向第一个元素的指针。内存中的p[]数组类似于(地址是假设的)：|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|688043|++p+
+200+++204+208++212++216+
%2B----%2B----%2B----%2B----%2B---%2B
%7C++2+%7C++3+%7C+5++%7C+6++%7C+8+%7C
%2B----%2B----%2B----%2B----%2B---%2B
++▲++++▲++++▲++++▲++++▲
++%7C++++%7C++++%7C++++%7C++++%7C+
++p++++p%2B1++p%2B2++p%2B3++p%2B3|code-block|syntax|javascript|688044|在x+=+p;之后，x也指向第一个元素。|688045|++p+
+200+++204+208++212++216+
%2B----%2B----%2B----%2B----%2B---%2B
%7C++2+%7C++3+%7C+5++%7C+6++%7C+8+%7C
%2B----%2B----%2B----%2B----%2B---%2B
+▲+▲+++▲++++▲++++▲++++▲
+%7C+%7C+++%7C++++%7C++++%7C++++%7C+
+%7C+p+++p%2B1++p%2B2++p%2B3++p%2B3
+%7C
+x+
%2B----%2B
%7C+200%7C
%2B----%2B|688046|在表达式y+=+&p;中，&p是int(*)[5]类型数组的指针，y是int**。(您必须得到用-Wall编译的警告(或错误))。|688047|读：p|688048|因为p和&p在价值上是相同的，所以y的地址值也与p相同。|688049|++p+
+200+++204+208++212++216+
%2B----%2B----%2B----%2B----%2B---%2B
%7C++2+%7C++3+%7C+5++%7C+6++%7C+8+%7C
%2B----%2B----%2B----%2B----%2B---%2B
+▲+▲+++▲++++▲++++▲++++▲
+%7C+%7C+++%7C++++%7C++++%7C++++%7C+
+%7C+p+++p%2B1++p%2B2++p%2B3++p%2B3
+%7C
+x+++++++++y
%2B----%2B++++%2B----%2B
%7C+200%7C++++%7C+200%7C
%2B----%2B++++%2B----%2B
+int*++++++int**|688050|你的第一张照片：|688051|+printf("p+value+is+%25d+and+p+points+to+%25d",p,&p);|688052|应写为：|688053|+printf("p+value+is+%25p+and+p+points+to+%25p",+(void*)p,+(void*)&p);
+//++++++++++++++++++%5E++++++++++++++++++%5E++|688054|使用%25p而不是%25d，因为您正在打印地址，而且void*的类型也是必要的，因为%25p需要void*。正如我所说，按价值计算，p和&p是相同的，两个地址都是相同的。|688055|第二印件f：|688056|printf("\n+x+is+%25d+\n",+x[1]);|688057|输出：3+as+x指向数组x[1]+==+*(x+%2B+1)+==+3中的第一个元素(在我的图x+%2B+1+==+204中)。|688058|第三印件f：|688059|printf("\n+y+is+%25d+\n",+y[0]);|688060|注y类型为int**，因此y[0]+==+*(y+%2B+0)+=+*y值存储在y类型*y+is+int*中。|688061|因此，由于y[0]是int*，所以您应该使用%25p而不是%25d。|688062|但是上面的printf语句打印第一个元素的值，即：2。|688063|类似地，y[1]打印3，y[2]打印5。|688064|编辑|BOLD|688065|当我打印y[1]时，它将打印5而不是3，y[2]被打印为8。|blockquote|688066|不，正如我前面解释过的那样，它输出@码页，其中sizeof(int)+==+sizeof(int*)可能在您的系统中sizeof(int*)+=+sizeof(int)的两倍(64位编译器)，所以当您在下一个位置旁边添加一个地址时。|688067|正如@WhozCraig评论的:试试y+=+&x;，你可能会有更好的运气。并打印您要传递的任何内容，应该是%25p的“指针”。|688068|更正你的代码。|688069|entityMap|0|LINK|mutability|MUTABLE|url|https://stackoverflow.com/questions/15177420/what-does-sizeofarr-return/15177499#15177499|1|http://codepad.org/vTaVOGoe^0|Z|3|0|0|1|6|A|1|0|0|4|7|D|2|G|9|X|1|Z|5|1C|5|0|2|1|2|1|0|0|2|1|4|2|H|1|O|1|0|0|0|0|0|0|2|2|7|2|M|5|12|2|16|5|1O|1|1Q|2|0|0|0|3|1|8|1|D|4|L|8|X|1|1A|5|0|0|0|1|1|5|5|D|4|L|8|W|2|12|1|15|2|1B|4|0|5|4|A|4|M|2|R|2|0|P|1|0|4|4|A|1|C|4|I|1|0|0|2|0|4|4|E|1|I|1|K|4|S|1|0|N|B|12|C|1M|C|21|B|I|2|1|0|I|7|1H|2|0|0^^$0|@$1|2|3|4|5|6|7|2A|8|@$9|2B|A|2C|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|2D|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|2E|8|@$9|2F|A|2G|B|C]|$9|2H|A|2I|B|C]]|D|@]|E|$]]|$1|M|3|N|5|H|7|2J|8|@]|D|@]|E|$I|J]]|$1|O|3|P|5|6|7|2K|8|@$9|2L|A|2M|B|C]|$9|2N|A|2O|B|C]|$9|2P|A|2Q|B|C]|$9|2R|A|2S|B|C]|$9|2T|A|2U|B|C]|$9|2V|A|2W|B|C]]|D|@]|E|$]]|$1|Q|3|R|5|6|7|2X|8|@$9|2Y|A|2Z|B|C]]|D|@$9|30|A|31|1|32]]|E|$]]|$1|S|3|T|5|6|7|33|8|@$9|34|A|35|B|C]|$9|36|A|37|B|C]|$9|38|A|39|B|C]|$9|3A|A|3B|B|C]]|D|@]|E|$]]|$1|U|3|V|5|H|7|3C|8|@]|D|@]|E|$I|J]]|$1|W|3|X|5|6|7|3D|8|@]|D|@]|E|$]]|$1|Y|3|Z|5|H|7|3E|8|@]|D|@]|E|$I|J]]|$1|10|3|11|5|6|7|3F|8|@]|D|@]|E|$]]|$1|12|3|13|5|H|7|3G|8|@]|D|@]|E|$I|J]]|$1|14|3|15|5|6|7|3H|8|@$9|3I|A|3J|B|C]|$9|3K|A|3L|B|C]|$9|3M|A|3N|B|C]|$9|3O|A|3P|B|C]|$9|3Q|A|3R|B|C]|$9|3S|A|3T|B|C]|$9|3U|A|3V|B|C]]|D|@]|E|$]]|$1|16|3|17|5|6|7|3W|8|@]|D|@]|E|$]]|$1|18|3|19|5|H|7|3X|8|@]|D|@]|E|$I|J]]|$1|1A|3|1B|5|6|7|3Y|8|@$9|3Z|A|40|B|C]|$9|41|A|42|B|C]|$9|43|A|44|B|C]|$9|45|A|46|B|C]|$9|47|A|48|B|C]|$9|49|A|4A|B|C]]|D|@]|E|$]]|$1|1C|3|1D|5|6|7|4B|8|@]|D|@]|E|$]]|$1|1E|3|1F|5|H|7|4C|8|@]|D|@]|E|$I|J]]|$1|1G|3|1H|5|6|7|4D|8|@$9|4E|A|4F|B|C]|$9|4G|A|4H|B|C]|$9|4I|A|4J|B|C]|$9|4K|A|4L|B|C]|$9|4M|A|4N|B|C]|$9|4O|A|4P|B|C]|$9|4Q|A|4R|B|C]|$9|4S|A|4T|B|C]]|D|@]|E|$]]|$1|1I|3|1J|5|6|7|4U|8|@$9|4V|A|4W|B|C]|$9|4X|A|4Y|B|C]|$9|4Z|A|50|B|C]|$9|51|A|52|B|C]]|D|@]|E|$]]|$1|1K|3|1L|5|6|7|53|8|@$9|54|A|55|B|C]]|D|@]|E|$]]|$1|1M|3|1N|5|6|7|56|8|@$9|57|A|58|B|C]|$9|59|A|5A|B|C]|$9|5B|A|5C|B|C]|$9|5D|A|5E|B|C]]|D|@]|E|$]]|$1|1O|3|1P|5|6|7|5F|8|@$9|5G|A|5H|B|1Q]]|D|@]|E|$]]|$1|1R|3|1S|5|1T|7|5I|8|@$9|5J|A|5K|B|C]|$9|5L|A|5M|B|C]|$9|5N|A|5O|B|C]|$9|5P|A|5Q|B|C]|$9|5R|A|5S|B|C]]|D|@]|E|$]]|$1|1U|3|1V|5|6|7|5T|8|@$9|5U|A|5V|B|C]|$9|5W|A|5X|B|C]|$9|5Y|A|5Z|B|C]|$9|60|A|61|B|C]]|D|@$9|62|A|63|1|64]]|E|$]]|$1|1W|3|1X|5|6|7|65|8|@$9|66|A|67|B|C]|$9|68|A|69|B|C]]|D|@]|E|$]]|$1|1Y|3|1Z|5|6|7|6A|8|@]|D|@]|E|$]]|$1|20|3|-4|5|6|7|6B|8|@]|D|@]|E|$]]]|21|$22|$5|23|24|25|E|$26|27]]|28|$5|23|24|25|E|$26|29]]]]

Remember array name can easily decays into pointer to first element in most expressions.
<code>p[]</code> array in memory is like (addresses are assumption): 

<pre><code> p 
 200 204 208 212 216 
+----+----+----+----+---+
| 2 | 3 | 5 | 6 | 8 |
+----+----+----+----+---+
 ▲ ▲ ▲ ▲ ▲
 | | | | | 
 p p+1 p+2 p+3 p+3
</code></pre>

After <code>x = p;</code>, <code>x</code> also pointer to first element. 

<pre><code> p 
 200 204 208 212 216 
+----+----+----+----+---+
| 2 | 3 | 5 | 6 | 8 |
+----+----+----+----+---+
 ▲ ▲ ▲ ▲ ▲ ▲
 | | | | | | 
 | p p+1 p+2 p+3 p+3
 |
 x 
+----+
| 200|
+----+
</code></pre>

In expression <code>y = &amp;p;</code> , <code>&amp;p</code> is pointer of array of type <code>int(*)[5]</code> and <code>y</code> is <code>int**</code>. (you must getting a warning (or error) compile with <code>-Wall</code>). 

Read: <a href="https://stackoverflow.com/questions/15177420/what-does-sizeofarr-return/15177499#15177499">Difference between <code>&amp;p</code> and <code>p</code></a> 

Because value-wise both <code>p</code> and <code>&amp;p</code> are same so address value of <code>y</code> is also same as <code>p</code>. 

<pre><code> p 
 200 204 208 212 216 
+----+----+----+----+---+
| 2 | 3 | 5 | 6 | 8 |
+----+----+----+----+---+
 ▲ ▲ ▲ ▲ ▲ ▲
 | | | | | | 
 | p p+1 p+2 p+3 p+3
 |
 x y
+----+ +----+
| 200| | 200|
+----+ +----+
 int* int**
</code></pre>

Your first printf: 

<pre><code> printf("p value is %d and p points to %d",p,&amp;p);
</code></pre>

Should be written as:

<pre><code> printf("p value is %p and p points to %p", (void*)p, (void*)&amp;p);
 // ^ ^ 
</code></pre>

Use <code>%p</code> instead of <code>%d</code> because you are printing addresses also typecast to <code>void*</code> is necessary because <code>%p</code> expects <code>void*</code>. As I said value-wise <code>p</code> and <code>&amp;p</code> are same both addresses are same. 

Second printf: 

<pre><code>printf("\n x is %d \n", x[1]);
</code></pre>

Outputs: <code>3</code> as <code>x</code> points to first element in array <code>x[1]</code> == <code>*(x + 1)</code> == <code>3</code> (in my figures <code>x + 1</code> == 204). 

Third printf: 

<pre><code>printf("\n y is %d \n", y[0]);
</code></pre>

Note <code>y</code> type is <code>int**</code> so <code>y[0]</code> == <code>*(y + 0)</code> = <code>*y</code> value stored at <code>y</code> type of <code>*y</code> is <code>int*</code>. 
So again because <code>y[0]</code> is <code>int*</code> you should use <code>%p</code> instead of <code>%d</code>. 

But the above printf statement prints value of first element that is: <code>2</code>. 

Similarly <code>y[1]</code> prints <code>3</code> and <code>y[2]</code> prints <code>5</code>. 

Edit

<blockquote>
 When I print <code>y[1]</code> it will print <code>5</code> instead of <code>3</code> and <code>y[2]</code> is printed as <code>8</code>. 
</blockquote>

No, It outputs as I explained above Check @<a href="http://codepad.org/vTaVOGoe" rel="nofollow noreferrer">codepade</a> where <code>sizeof(int)</code> == <code>sizeof(int*)</code> probably in your system <code>sizeof(int*)</code> = twice of <code>sizeof(int)</code> (64-bit compiler) so when you add one you address next to next location. 

As @WhozCraig commented: Try <code>y = &amp;x;</code> You may have better luck. And print anything you're passing that should be a "pointer" with <code>%p</code>. 

Correct your code.

blocks|key|688093|text|好的，这个问题已经回答了，答案也被接受了，但是即使是被接受的答案也不能解释最初的海报看到的奇怪的结果:为什么y[1]和y[2]打印5和8？这是解释。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|688094|发信人:你从以下陈述中得到了什么输出？|688095|printf+("Size+of+integer:+%25zu\n",+sizeof+(int));
printf+("Size+of+pointer:+%25zu\n",+sizeof+(int*));|code-block|syntax|javascript|688096|我打赌输出是：|688097|Size+of+integer:+4
Size+of+pointer:+8|688098|换句话说，我猜您是在64位计算机上编译的，其中整数的大小是4字节，指针的大小是8字节。基于这个假设，下面是正在发生的事情。|688099|p是一个数组。除了少数例外，当在任何表达式中使用时，数组的名称“衰变”到指向其第一个元素的指针。因此，每当您访问p的值时，它都会产生第一个元素的地址。|688100|&p是数组“衰变”到指针规则的例外之一。当应用于数组的名称时，地址运算符返回指向整个数组的指针--而不是指向数组第一个元素的指针。|688101|这意味着p和&p具有相同的值，但它们在语义上非常不同。打印时，您将得到相同的值：|688102|+printf("p+value+is+%25p+and+p+points+to+%25p",+p,+&p);++//+use+%25p+and+not+%25d+for+addresses|688103|但是，这并不意味着p和&p引用的是相同的东西。p是数组的第一个元素的地址，即&p[0]。另一方面，&p是由5个整数组成的整数组的地址。|BOLD|688104|因此，当您按照以下方式定义x和y时：|688105|int*+x+=+p;
int**+y+=+&p;|688106|为x分配一个指向数组第一个元素的指针；为y分配一个指向整个数组的指针。这是一个重要的区别！|688107|此外，声明y的方式与您要分配给它的值之间存在不匹配。&p的类型是int+(*)+[5]；指向5+int数组的指针。y只是指向单个int的指针。您的编译器应该给您一个关于这种不匹配的警告。我的有：|688108|Warning:+incompatible+pointer+types+assigning+to+'int**'+from+'int+(*)+5'|688109|这种不匹配解释了在打印y[1]和y[2]值时出现的奇怪结果。让我们来看看这些值是怎么回事。|688110|如您所知，数组下标是从数组开始时的抵消：|688111|x[0]+==+*(x+%2B+0)|688112|因此，x[0]产生数组的第一个元素，即2。|688113|x[1]+==+*(x+%2B+1)|688114|但是x是一个指向int的指针。那么，在加法x+%2B+1中到底发生了什么呢？记住指针算术是如何工作的。向指针中添加整数意味着实际上要将整数乘以指向的.元素的大小(在本例中为：|688115|x+%2B+1+==+x+%2B+(1+*+sizeof(int))|688116|由于系统上的sizeof(int)是4，所以x[1]的值是数组中的下一个整数，即3。|688117|那么，当您打印y[0]时，这是如何评估的呢？|688118|y[0]+==+*(y+%2B+0)|688119|因此，打印位于y指向的地址的值，即p地址。这是p的第一个元素，因此得到了结果2。|688120|打印y[1]时会发生什么？|688121|y[1]+==+*(y+%2B+1)|688122|但是y是什么呢？这是一个pointer+to+a+pointer+to+an+int。因此，当您将1添加到y时，指针算法的工作方式是再次添加1*指向的元素类型的大小。|688123|y+%2B+1+==+y+%2B+(1+*+sizeof+(int*))|688124|int*的大小是8个字节，而不是4个字节！因此，每次增量y+1时，都会增加8个字节，即两个整数的大小。因此，当您取消对该值的引用时，您将得到的不是数组中的下一个整数，而是距数组2的整数。|688125|为了更清楚地解释:让我们假设数组从元素1000开始。然后，由于每个int需要4个字节，因此如下所示：|688126|+Address++++++Element
-----------------------
++1000++++++++++2
++1004++++++++++3
++1008++++++++++5
++1012++++++++++6
++1016++++++++++8


+p+==+&p+==+x+==+y+==+1000
+*x+==+*y+==+2|688127|当你把1加到x的时候，你就是在添加1*+sizeof(int)，也就是说，你实际上是在添加4，所以你得到了1004，而*(x+%2B+1)，或者x[1]，给了你3。|688128|但是当你把1加到y的时候，你就是在添加1*+sizeof(int*)，也就是说，你实际上是在添加8，所以你得到了1008，而*(y+%2B+1)给出了地址1008或5的元素。|688129|这解释了您正在获得的输出。然而，这并不是一种合理的编码方式。您不应该期望指针的大小总是8字节。不应将int+(*)+[]分配给int**。您不应该取消指向指向int的指针的引用，并期望得到int结果。总是注意编译器警告。|688130|entityMap^0|1I|4|1N|4|0|0|0|0|0|0|0|1|1K|1|0|0|2|0|4|1|6|2|0|0|9|1|B|2|N|1|12|5|1D|2|1O|7|0|0|I|D|1|F|1|0|0|0|19|1|1|K|1|0|0|2P|5|1|Q|2|W|B|1C|3|1L|1|1S|3|0|0|0|19|B|4|G|4|0|0|K|0|0|0|L|3|4|0|0|0|2D|2|1|L|5|0|0|0|16|6|B|M|4|0|0|M|7|4|0|0|0|14|7|1|H|1|N|1|0|0|D|2|4|0|0|0|2B|2|1|C|U|1H|1|0|0|0|2L|0|4|S|1|0|0|1E|X|3|0|0|0|28|K|B|1N|8|1Y|4|0|0|2D|M|C|1Q|8|0|0|32|1E|A|1R|5|27|3|2M|3|0^^$0|@$1|2|3|4|5|6|7|2L|8|@$9|2M|A|2N|B|C]|$9|2O|A|2P|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|2Q|8|@]|D|@]|E|$]]|$1|H|3|I|5|J|7|2R|8|@]|D|@]|E|$K|L]]|$1|M|3|N|5|6|7|2S|8|@]|D|@]|E|$]]|$1|O|3|P|5|J|7|2T|8|@]|D|@]|E|$K|L]]|$1|Q|3|R|5|6|7|2U|8|@]|D|@]|E|$]]|$1|S|3|T|5|6|7|2V|8|@$9|2W|A|2X|B|C]|$9|2Y|A|2Z|B|C]]|D|@]|E|$]]|$1|U|3|V|5|6|7|30|8|@$9|31|A|32|B|C]]|D|@]|E|$]]|$1|W|3|X|5|6|7|33|8|@$9|34|A|35|B|C]|$9|36|A|37|B|C]]|D|@]|E|$]]|$1|Y|3|Z|5|J|7|38|8|@]|D|@]|E|$K|L]]|$1|10|3|11|5|6|7|39|8|@$9|3A|A|3B|B|C]|$9|3C|A|3D|B|C]|$9|3E|A|3F|B|C]|$9|3G|A|3H|B|C]|$9|3I|A|3J|B|C]|$9|3K|A|3L|B|12]]|D|@]|E|$]]|$1|13|3|14|5|6|7|3M|8|@$9|3N|A|3O|B|12]|$9|3P|A|3Q|B|C]|$9|3R|A|3S|B|C]]|D|@]|E|$]]|$1|15|3|16|5|J|7|3T|8|@]|D|@]|E|$K|L]]|$1|17|3|18|5|6|7|3U|8|@$9|3V|A|3W|B|12]|$9|3X|A|3Y|B|C]|$9|3Z|A|40|B|C]]|D|@]|E|$]]|$1|19|3|1A|5|6|7|41|8|@$9|42|A|43|B|12]|$9|44|A|45|B|C]|$9|46|A|47|B|C]|$9|48|A|49|B|C]|$9|4A|A|4B|B|C]|$9|4C|A|4D|B|C]|$9|4E|A|4F|B|C]]|D|@]|E|$]]|$1|1B|3|1C|5|J|7|4G|8|@]|D|@]|E|$K|L]]|$1|1D|3|1E|5|6|7|4H|8|@$9|4I|A|4J|B|12]|$9|4K|A|4L|B|C]|$9|4M|A|4N|B|C]]|D|@]|E|$]]|$1|1F|3|1G|5|6|7|4O|8|@$9|4P|A|4Q|B|12]]|D|@]|E|$]]|$1|1H|3|1I|5|J|7|4R|8|@]|D|@]|E|$K|L]]|$1|1J|3|1K|5|6|7|4S|8|@$9|4T|A|4U|B|12]|$9|4V|A|4W|B|C]]|D|@]|E|$]]|$1|1L|3|1M|5|J|7|4X|8|@]|D|@]|E|$K|L]]|$1|1N|3|1O|5|6|7|4Y|8|@$9|4Z|A|50|B|12]|$9|51|A|52|B|C]|$9|53|A|54|B|C]]|D|@]|E|$]]|$1|1P|3|1Q|5|J|7|55|8|@]|D|@]|E|$K|L]]|$1|1R|3|1S|5|6|7|56|8|@$9|57|A|58|B|12]|$9|59|A|5A|B|C]|$9|5B|A|5C|B|C]]|D|@]|E|$]]|$1|1T|3|1U|5|6|7|5D|8|@$9|5E|A|5F|B|12]|$9|5G|A|5H|B|C]]|D|@]|E|$]]|$1|1V|3|1W|5|J|7|5I|8|@]|D|@]|E|$K|L]]|$1|1X|3|1Y|5|6|7|5J|8|@$9|5K|A|5L|B|12]|$9|5M|A|5N|B|C]|$9|5O|A|5P|B|C]|$9|5Q|A|5R|B|C]]|D|@]|E|$]]|$1|1Z|3|20|5|6|7|5S|8|@$9|5T|A|5U|B|12]|$9|5V|A|5W|B|C]]|D|@]|E|$]]|$1|21|3|22|5|J|7|5X|8|@]|D|@]|E|$K|L]]|$1|23|3|24|5|6|7|5Y|8|@$9|5Z|A|60|B|12]|$9|61|A|62|B|C]|$9|63|A|64|B|C]|$9|65|A|66|B|C]]|D|@]|E|$]]|$1|25|3|26|5|J|7|67|8|@]|D|@]|E|$K|L]]|$1|27|3|28|5|6|7|68|8|@$9|69|A|6A|B|12]|$9|6B|A|6C|B|C]|$9|6D|A|6E|B|C]]|D|@]|E|$]]|$1|29|3|2A|5|6|7|6F|8|@$9|6G|A|6H|B|12]|$9|6I|A|6J|B|C]]|D|@]|E|$]]|$1|2B|3|2C|5|J|7|6K|8|@]|D|@]|E|$K|L]]|$1|2D|3|2E|5|6|7|6L|8|@$9|6M|A|6N|B|12]|$9|6O|A|6P|B|C]|$9|6Q|A|6R|B|C]|$9|6S|A|6T|B|C]]|D|@]|E|$]]|$1|2F|3|2G|5|6|7|6U|8|@$9|6V|A|6W|B|12]|$9|6X|A|6Y|B|C]|$9|6Z|A|70|B|C]]|D|@]|E|$]]|$1|2H|3|2I|5|6|7|71|8|@$9|72|A|73|B|12]|$9|74|A|75|B|C]|$9|76|A|77|B|C]|$9|78|A|79|B|C]|$9|7A|A|7B|B|C]]|D|@]|E|$]]|$1|2J|3|-4|5|6|7|7C|8|@]|D|@]|E|$]]]|2K|$]]

Okay, this question has been answered and an answer has been accepted, but even the accepted answer does not explain the weird results the original poster was seeing: why do <code>y[1]</code> and <code>y[2]</code> print 5 and 8? Here is the explanation. 

Original poster: What output do you get from the following statements? 

<pre><code>printf ("Size of integer: %zu\n", sizeof (int));
printf ("Size of pointer: %zu\n", sizeof (int*));
</code></pre>

I'm going to bet that the output is:

<pre><code>Size of integer: 4
Size of pointer: 8
</code></pre>

In other words, I'm guessing that you're compiling on a 64-bit machine where the size of an integer is 4 bytes and the size of a pointer is 8 bytes. Based on that assumption, here's what is happening.

<code>p</code> is an array. With a few exceptions, when used in any expression, the array's name "decays" to a pointer to its first element. Any time you access the value of <code>p</code>, therefore, it will yield the address of its first element. 

<code>&amp;p</code> is one of those exceptions to the rule about arrays "decaying" to pointers. The address-of operator, when applied to an array's name, returns a pointer to the entire array--not a pointer to a pointer to the first element of the array. 

What this means is that <code>p</code> and <code>&amp;p</code> have the same value, but they are semantically very different. You will get the same value when you print:

<pre><code> printf("p value is %p and p points to %p", p, &amp;p); // use %p and not %d for addresses
</code></pre>

However, this does not mean that <code>p</code> and <code>&amp;p</code> refer to the same thing. <code>p</code> is the address of first element of the array, i.e., <code>&amp;p[0]</code>. On the other hand, <code>&amp;p</code> is the address of the entire array of 5 integers.

So when you define <code>x</code> and <code>y</code> as follows:

<pre><code>int* x = p;
int** y = &amp;p;
</code></pre>

<code>x</code> is assigned a pointer to the first element of the array; <code>y</code> is assigned a pointer to the entire array. This is an important difference!

There is, moreover, a mismatch between how <code>y</code> is declared, and the value you're assigning to it. <code>&amp;p</code> is of type <code>int (*) [5]</code>; a pointer to an array of 5 <code>int</code>. <code>y</code> is merely a pointer to a pointer to a single <code>int</code>. Your compiler should give you a warning about this mismatch. Mine does: 

<pre><code>Warning: incompatible pointer types assigning to 'int**' from 'int (*) 5'
</code></pre>

This mismatch explains the weird results while printing values of <code>y[1]</code> and <code>y[2]</code>. Let's look at what's going on with the values. 

As you know, array subscripts are offsets from the beginning of the array:

<pre><code>x[0] == *(x + 0)
</code></pre>

So <code>x[0]</code> yields the first element of the array, i.e., 2. Similarly

<pre><code>x[1] == *(x + 1)
</code></pre>

But <code>x</code> is a pointer to int. So what is actually happining in the addition <code>x + 1</code>? Remember how pointer arithmetic works. Adding an integer to a pointer means you're actually adding that integer times the size of the element pointed to. In this case:

<pre><code>x + 1 == x + (1 * sizeof(int))
</code></pre>

Since <code>sizeof(int)</code> is 4 on your system, the value of <code>x[1]</code> is the next integer in the array, which is 3.

So then, when you print <code>y[0]</code>, how is this evaluated? 

<pre><code>y[0] == *(y + 0)
</code></pre>

Hence, the value that is at the address pointed to by <code>y</code>, i.e., at the address of <code>p</code>, is printed. This is the first element of <code>p</code>, hence you get the result 2.

What happens when you print <code>y[1]</code>? 

<pre><code>y[1] == *(y + 1)
</code></pre>

But what is <code>y</code>? It is a <code>pointer to a pointer to an int</code>. So when you add 1 to <code>y</code>, the way pointer arithmetic works is it again adds 1 * the size of the type of the element pointed to. 

<pre><code>y + 1 == y + (1 * sizeof (int*))
</code></pre>

The size of an <code>int*</code> is 8 bytes, not four! So every time you increment <code>y</code> by 1, you're incrementing it by 8 bytes, or the size of two integers. Hence, when you dereference that value, you are getting not the next integer in the array, but the integer that is two away. 

To explain more clearly: Let us assume that the array begins at element 1000. Then, because each <code>int</code> takes four bytes, the following is the case:

<pre><code> Address Element
-----------------------
 1000 2
 1004 3
 1008 5
 1012 6
 1016 8


 p == &amp;p == x == y == 1000
 *x == *y == 2
</code></pre>

When you add 1 to x, you are adding 1 * <code>sizeof(int)</code>, i.e., you are actually adding 4. So you get 1004, and <code>*(x + 1)</code>, or <code>x[1]</code>, gives you 3.

But when you add 1 to y, you are adding 1 * <code>sizeof(int*)</code>, i.e., you are actually adding 8. So you get 1008, and <code>*(y + 1)</code> gives you the element at address 1008, or 5. 

This explains the output you are getting. This is NOT, however, a reasonable way to code. You should not expect that the size of a pointer is always going to be 8 bytes. You should not assign an <code>int (*) []</code> to an <code>int**</code>. You should not dereference a pointer to a pointer to an <code>int</code> and expect to get an <code>int</code> result. And always heed compiler warnings.

blocks|key|688151|text|我认为你的代码不能成功编译。&p的类型是char+(*p)[10]，但是y的类型是char+**，|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|688152|cannot+convert+from+'char+(*)[10]'+to+'char+**'|code-block|syntax|javascript|688153|entityMap^0|E|2|K|D|10|1|15|7|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@$9|N|A|O|B|C]|$9|P|A|Q|B|C]|$9|R|A|S|B|C]|$9|T|A|U|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|V|8|@]|D|@]|E|$I|J]]|$1|K|3|-4|5|6|7|W|8|@]|D|@]|E|$]]]|L|$]]

I think you code cann't compile successfully.
The type of <code>&amp;p</code> is <code>char (*p)[10]</code>, but the type of <code>y</code> is <code>char **</code>,

<pre><code>cannot convert from 'char (*)[10]' to 'char **'
</code></pre>

I created a pointer to pointer and a <code>int</code> array, but when I try to access the array via my pointer to pointer, it skips some elements and moves by two elements at a time (eg: from 1 to 3).
Here is my code:

<pre><code>int main(void) {
 int c=10;
 int p[5]={2,3,5,6,8};
 int *x;
 int **y;
 x=p;
 y=&amp;p;
 printf("p value is %d and p points to %d",p,&amp;p);
 printf("\n x is %d \n",x[1]);
 printf("\n y is %d \n",y[0]);

 return 0;
}
</code></pre>

When I print <code>y[1]</code> it will print 5 instead of 3 and <code>y[2]</code> is printed as 8. I can't think of the reason. Can any one help me on this? Pointer <code>x</code> is is working fine and moves along the correct elements as <code>x[0]=2</code>, <code>x[1]=3</code>, <code>x[5]=5</code>.
also can any one explain why i get same value for p and &amp;p

Pointer to pointer issue

翻译质量差，导致语言生硬或混乱。

没有提供实际的解决方法或示例。

解答不清晰，无法理解或解决问题。

页面排版不美观，阅读体验差。

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

涵盖代码开发、场景应用、自动测试全流程，助你从零构建专属AI助手

一站式MCP教程库，解锁AI应用新玩法

我创建了指向指针和int数组的指针，但是当我试图通过指针访问数组时，它跳过一些元素并一次由两个元素移动(例如:从1到3)。这是我的代码：int main(void) {    int c=10;    int p[5]={2,3,5,6,8};    int *x;    int **y;    x=p;    y=&...

问指针问题
EN

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问指针问题EN