blocks|key|4032819|text|int+*ptr[10];|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|4032820|这是一个由10个int*指针组成的数组，而不是您想象的那样指向一个由10个int组成的数组的指针|4032821|int+(*ptr)[10];|4032822|这是指向10+int数组的指针|4032823|我相信它与int+*ptr;相同，因为两者都可以指向一个数组，但是给定的表单只能指向一个由10个int组成的数组|4032824|entityMap^0|0|D|0|8|4|11|3|0|0|F|0|7|3|0|5|9|1C|3|0^^$0|@$1|2|3|4|5|6|7|P|8|@$9|Q|A|R|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|S|8|@$9|T|A|U|B|C]|$9|V|A|W|B|C]]|D|@]|E|$]]|$1|H|3|I|5|6|7|X|8|@$9|Y|A|Z|B|C]]|D|@]|E|$]]|$1|J|3|K|5|6|7|10|8|@$9|11|A|12|B|C]]|D|@]|E|$]]|$1|L|3|M|5|6|7|13|8|@$9|14|A|15|B|C]|$9|16|A|17|B|C]]|D|@]|E|$]]|$1|N|3|-4|5|6|7|18|8|@]|D|@]|E|$]]]|O|$]]

<code>int *ptr[10];</code>

This is an array of 10 <code>int*</code> pointers, not as you would assume, a pointer to an array of 10 <code>int</code>s

<code>int (*ptr)[10];</code>

This is a pointer to an array of 10 <code>int</code> 

It is I believe the same as <code>int *ptr;</code> in that both can point to an array, but the given form can ONLY point to an array of 10 <code>int</code>s

blocks|key|105589|text|int+(*ptr)[10];|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|105590|是一个指向10个整型数组的指针。|unstyled|105591|int+*ptr[10];|105592|是由10个指针组成的数组。|105593|段故障的原因：|offset|length|style|BOLD|105594|*ptr=a；printf("%25d"，*ptr1)；|105595|这里，您将数组a的地址分配给ptr，该地址将指向元素a[0]。这相当于：*ptr=&a[0];|CODE|105596|但是，当您打印时，您访问的是ptr[1]，这是一个未初始化的指针，它是未定义的行为，因此会产生segfault。|105597|entityMap^0|0|0|0|0|4|3|0|0|7|1|E|3|Q|4|10|B|0|E|6|0^^$0|@$1|2|3|4|5|6|7|Z|8|@]|9|@]|A|$B|C]]|$1|D|3|E|5|F|7|10|8|@]|9|@]|A|$]]|$1|G|3|H|5|6|7|11|8|@]|9|@]|A|$B|C]]|$1|I|3|J|5|F|7|12|8|@]|9|@]|A|$]]|$1|K|3|L|5|F|7|13|8|@$M|14|N|15|O|P]]|9|@]|A|$]]|$1|Q|3|R|5|F|7|16|8|@]|9|@]|A|$]]|$1|S|3|T|5|F|7|17|8|@$M|18|N|19|O|U]|$M|1A|N|1B|O|U]|$M|1C|N|1D|O|U]|$M|1E|N|1F|O|U]]|9|@]|A|$]]|$1|V|3|W|5|F|7|1G|8|@$M|1H|N|1I|O|U]]|9|@]|A|$]]|$1|X|3|-4|5|F|7|1J|8|@]|9|@]|A|$]]]|Y|$]]

<pre><code>int (*ptr)[10];
</code></pre>

is a pointer to an array of 10 ints.

<pre><code>int *ptr[10];
</code></pre>

is an array of 10 pointers.

Reason for segfault:

*ptr=a;
printf("%d",*ptr[1]);

Here you are assigning the address of array <code>a</code> to <code>ptr</code> which would point to the element <code>a[0]</code>. This is equivalent to: <code>*ptr=&amp;a[0];</code>

However, when you print, you access <code>ptr[1]</code> which is an uninitialized pointer which is undefined behaviour and thus giving segfault.

blocks|key|4514314|text|int(*)[10]是一个指向包含10个成员的整数数组的指针。也就是说，它指向int+a[10]。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|4514315|其中as+int+*[10]是整数指针数组|4514316|#include+<stdio.h>
int+main()
{

int+*ptr[10];
int+a[10]={0,1,2,3,4,5,6,7,8,9};

printf("\n%25p++%25p",+ptr[0],+a);

*ptr=a;+//ptr[0]+is+assigned+with+address+of+array+a.

printf("\n%25p++%25p",+ptr[0],+a);+//gives+you+same+address

printf("\n%25d",*ptr[0]);+//Prints+zero.+If+*ptr[1]+is+given+then+*(ptr+%2B+1)+i.e+ptr[1]+is+considered+which+is+uninitialized+one.

return+0;
}|code-block|syntax|javascript|4514317|entityMap^0|0|A|13|9|0|5|9|0|0^^$0|@$1|2|3|4|5|6|7|O|8|@$9|P|A|Q|B|C]|$9|R|A|S|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|T|8|@$9|U|A|V|B|C]]|D|@]|E|$]]|$1|H|3|I|5|J|7|W|8|@]|D|@]|E|$K|L]]|$1|M|3|-4|5|6|7|X|8|@]|D|@]|E|$]]]|N|$]]

<code>int(*)[10]</code> is a pointer to an int array with 10 members. i.e it points to <code>int a[10]</code>.

where as <code>int *[10]</code> is array of integer pointers

<pre><code>#include &lt;stdio.h&gt;
int main()
{

int *ptr[10];
int a[10]={0,1,2,3,4,5,6,7,8,9};

printf("\n%p %p", ptr[0], a);

*ptr=a; //ptr[0] is assigned with address of array a.

printf("\n%p %p", ptr[0], a); //gives you same address

printf("\n%d",*ptr[0]); //Prints zero. If *ptr[1] is given then *(ptr + 1) i.e ptr[1] is considered which is uninitialized one.

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

blocks|key|4032903|text|int+(*p)10表示p现在是指向大小为10的整数数组的指针。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|4032904|int+*p10表示p是由10个整数指针组成的数组。|4032905|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|F|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|G|8|@]|9|@]|A|$]]|$1|D|3|-4|5|6|7|H|8|@]|9|@]|A|$]]]|E|$]]

int (*p)[10] means that p is now a pointer to an integer array of size 10. 

int *p[10] means that p is an array of 10 integer pointers .

blocks|key|683183|text|int+(*p)[10]是一个指针，指向每行包含10个整数的数组，即可以有任意数量的行。基本上，它可以用来指向一个2D数组，并且可以通过递增*(p%2Bi)[10]的i来访问维数，这与a[i][10]相同，这里是'i=1,2,3...'来访问1,2,3..+rows。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|683184|其中，as，int+*p[10]是一个包含10个整数指针的数组。|683185|例如，如果阵列是二维，即|683186|b[2][10]={{0,1,2,3,4,5,6,7,8,9},{10,11,12,13,14,15,16,17,18,19}};基本上，(*ptr)[10]+//+where+the+higher+dimension+index+is+omitted+i.e,+2可以用作指向像(*ptr)[10]+=+&b这样的数组(每行包含10个元素，即第一维)的二维指针。在printf("%25d",(*ptr)[1]);中，提供的(*ptr)与*(ptr%2B0)的计算结果为第一个维度，即值为0的b[0][0]。像wise一样，要访问数组b[1][0]的第二维，表达式将是**(ptr%2B1)或*(ptr%2B1)[0]，或者*(*(ptr%2Bi)%2Bj);+//+where+i=1+and+j=0给出第二维的第一个元素，即10。|683187|我已经回答了很久了，所以很容易理解。|683188|entityMap^0|0|C|1Y|A|29|1|2I|8|2W|C|3B|C|0|6|A|0|0|0|1T|1X|1S|3W|F|53|N|5V|6|62|8|6R|7|7C|7|7T|9|83|B|8H|Z|0|0^^$0|@$1|2|3|4|5|6|7|P|8|@$9|Q|A|R|B|C]|$9|S|A|T|B|C]|$9|U|A|V|B|C]|$9|W|A|X|B|C]|$9|Y|A|Z|B|C]|$9|10|A|11|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|12|8|@$9|13|A|14|B|C]]|D|@]|E|$]]|$1|H|3|I|5|6|7|15|8|@]|D|@]|E|$]]|$1|J|3|K|5|6|7|16|8|@$9|17|A|18|B|C]|$9|19|A|1A|B|C]|$9|1B|A|1C|B|C]|$9|1D|A|1E|B|C]|$9|1F|A|1G|B|C]|$9|1H|A|1I|B|C]|$9|1J|A|1K|B|C]|$9|1L|A|1M|B|C]|$9|1N|A|1O|B|C]|$9|1P|A|1Q|B|C]|$9|1R|A|1S|B|C]]|D|@]|E|$]]|$1|L|3|M|5|6|7|1T|8|@]|D|@]|E|$]]|$1|N|3|-4|5|6|7|1U|8|@]|D|@]|E|$]]]|O|$]]

<code>int (*p)[10]</code> is a pointer to an array of 10 integers in each row i.e there can be any number of rows. basically it can be used to point to a 2D array and the dimensions can be accessed by incrementing <code>i</code> for <code>*(p+i)[10]</code> which is same as <code>a[i][10]</code>, here <code>'i=1,2,3...'</code> to access <code>1,2,3.. rows</code>.

where as, <code>int *p[10]</code> is an array of 10 integer pointers.

If array is two dimesional i.e, for example 

<code>b[2][10]={{0,1,2,3,4,5,6,7,8,9},{10,11,12,13,14,15,16,17,18,19}};</code>
basically, 
<code>(*ptr)[10] // where the higher dimension index is omitted i.e, 2</code> can be used as two dimensional pointer to an array(containing 10 elements in each row i.e, the 1st dimension) like <code>(*ptr)[10] = &amp;b</code>.
In the <code>printf("%d",(*ptr)[1]);</code> as provided <code>(*ptr)</code> is same as <code>*(ptr+0)</code>evaluates to the first dimension i.e, <code>b[0][0]</code> which value is 0. like wise, to access the 2nd dimension of the array <code>b[1][0]</code> the expression will be <code>**(ptr+1)</code> or <code>*(ptr+1)[0]</code> or <code>*(*(ptr+i)+j);
// where i=1 and j=0</code> gives the first element of the 2nd dimension i.e, 10. 

I've answered it long so to understand it easy.

blocks|key|683205|text|(*ptr)[10]仅有的两个用例是：|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|683206|使用二维arrays;|683207|typedef定长数组时的|unordered-list-item|683208|。|683209|683210|683211|由于第一个案例已经在上面由Sree解释过了，所以我将解释更具异国情调的用例。|683212|++++#include+<stdio.h>

typedef+int+arr1d10[10];
typedef+int+arr2d3[3][3];

void+test1d0(arr1d10+*arr)
{
++++/*+This+is+the+same+as+the+case+with+function+test1d1().+*/
++++printf("Element:+%25d\n",+(*arr)[0]);
}

void+test1d1(int+(*arr)[10])
{
++++/*+As+arr+is+a+pointer+to+an+array+of+10+integers,+pointer+arithmetic+will+work+with+the+size+of+an+array+of+10+integers,+i.e.+
+++++++when+you+increment+arr+it+will+increment+by+sizeof(arr1d10),+which+is+40+bytes.
+++++++That's+why+when+you+dereference+it,+you+can't+simply+do+arr[1],+because+it+will+increment+arr+by+40+bytes+forward.
+++++++Also+when+dereferencing+it,+because+it+thinks+it+points+to+a+whole+array+it+will+give+you+that+array+-+it's+address.
+++++++This+is+another+reason+you+can't+do+just+arr[i],+because+those+will+be+just+addresses.
+++++++The+correct+way+is+to+dereference+it+once(*arr)),+to+get+the+address+(think+of+implicitely+casting+to+int*)+and+then+you+can+do+as+usually+(*arr)[1]).
++++*/
++++printf("Element:+%25d\n",+(*arr)[1]);
}

void+test2d0(arr2d3+*arr2d)
{
++++/*+This+is+a+little+more+complicated,+but+the+principle+is+the+same+as+above.+*/
++++printf("Element:+%25d\n",+(*arr2d)[0][0]);
}

void+test2d1(int+(*arr2d)[3][3])
{
++++printf("Element:+%25d\n",+(*arr2d)[0][1]);
}

int+main(void)
{
++++arr1d10+arr1d+=+{0,+1,+2};
++++arr2d3+arr2d+=+{+{0,1},{2,3},{3,4}};
++++int+(*p1d)[10]+=+&arr1d;+
++++int+(*p2d)[3][3]+=+&arr2d;

++++printf("**********+PRINT+1D+array+**********\n");
++++test1d0(&arr1d);
++++test1d1(&arr1d);
++++test1d0(p1d);
++++test1d1(p1d);

++++printf("**********+PRINT+2D+array+**********\n");
++++test2d0(&arr2d);
++++test2d1(&arr2d);
++++test2d0(p2d);
++++test2d1(p2d);

++++return+0;
}|code-block|syntax|javascript|683213|entityMap^0|0|A|0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|X|8|@$9|Y|A|Z|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|10|8|@]|D|@]|E|$]]|$1|H|3|I|5|J|7|11|8|@]|D|@]|E|$]]|$1|K|3|L|5|J|7|12|8|@]|D|@]|E|$]]|$1|M|3|-4|5|6|7|13|8|@]|D|@]|E|$]]|$1|N|3|-4|5|6|7|14|8|@]|D|@]|E|$]]|$1|O|3|P|5|6|7|15|8|@]|D|@]|E|$]]|$1|Q|3|R|5|S|7|16|8|@]|D|@]|E|$T|U]]|$1|V|3|-4|5|6|7|17|8|@]|D|@]|E|$]]]|W|$]]

The only two use cases for <code>(*ptr)[10]</code> are:

<ul>
<li>when working with two-dimensional arrays;</li>
<li>typedef fixed length arrays.</li>
</ul>

Since the first case was already explained above by Sree harsha Punyasamudram,
I am going to explain the more exotic use case.

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

typedef int arr1d10[10];
typedef int arr2d3[3][3];

void test1d0(arr1d10 *arr)
{
 /* This is the same as the case with function test1d1(). */
 printf("Element: %d\n", (*arr)[0]);
}

void test1d1(int (*arr)[10])
{
 /* As arr is a pointer to an array of 10 integers, pointer arithmetic will work with the size of an array of 10 integers, i.e. 
 when you increment arr it will increment by sizeof(arr1d10), which is 40 bytes.
 That's why when you dereference it, you can't simply do arr[1], because it will increment arr by 40 bytes forward.
 Also when dereferencing it, because it thinks it points to a whole array it will give you that array - it's address.
 This is another reason you can't do just arr[i], because those will be just addresses.
 The correct way is to dereference it once(*arr)), to get the address (think of implicitely casting to int*) and then you can do as usually (*arr)[1]).
 */
 printf("Element: %d\n", (*arr)[1]);
}

void test2d0(arr2d3 *arr2d)
{
 /* This is a little more complicated, but the principle is the same as above. */
 printf("Element: %d\n", (*arr2d)[0][0]);
}

void test2d1(int (*arr2d)[3][3])
{
 printf("Element: %d\n", (*arr2d)[0][1]);
}

int main(void)
{
 arr1d10 arr1d = {0, 1, 2};
 arr2d3 arr2d = { {0,1},{2,3},{3,4}};
 int (*p1d)[10] = &amp;arr1d; 
 int (*p2d)[3][3] = &amp;arr2d;

 printf("********** PRINT 1D array **********\n");
 test1d0(&amp;arr1d);
 test1d1(&amp;arr1d);
 test1d0(p1d);
 test1d1(p1d);

 printf("********** PRINT 2D array **********\n");
 test2d0(&amp;arr2d);
 test2d1(&amp;arr2d);
 test2d0(p2d);
 test2d1(p2d);

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

For the following code:

<pre><code> int (*ptr)[10];
 int a[10]={99,1,2,3,4,5,6,7,8,9};
 ptr=&amp;a;
 printf("%d",(*ptr)[1]);
</code></pre>

What should it print? I'm expecting the garbage value here but the output is <code>1</code>. 
(for which I'm concluding that initializing this way pointer array i.e <code>ptr[10]</code> would start pointing to elements of <code>a[10]</code> in order).

But what about this code fragment:

<pre><code>int *ptr[10];
int a[10]={0,1,2,3,4,5,6,7,8,9};
*ptr=a;
printf("%d",*ptr[1]);
</code></pre>

It is giving the segmentation fault.

Difference between *ptr[10] and (*ptr)[10]

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

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

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

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

文章

问答

视频

教程

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

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

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

腾讯云数据库专区

腾讯云智能顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

EdgeOne AI 安全实战专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

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

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

聚焦“写作效率、视觉美观与运行性能”三方面进行全面升级，为您提供更高效、稳定的创作环境

社区富文本&Markdown编辑器全新改版上线，欢迎大家体验!

诚挚邀请您参与本次调研，分享您的真实使用感受与建议。您的反馈至关重要，感谢您的支持与参与！

社区新版编辑器体验调研

以获取以下代码：    int (*ptr)[10];    int a[10]={99,1,2,3,4,5,6,7,8,9};    ptr=&a;    printf("%d",(*ptr)[1]);它应该打印什么？我期待这里的垃圾值，但输出是1。(我的结论是，以这种方式初始化指针数组，即ptr[10]将开始按顺序指向a[10]的元素)。但是下面的代码片段如何呢：int *ptr[10];in

问ptr[10]和(ptr)之间的差异[10]
EN

回答 6

Stack Overflow用户

Stack Overflow用户

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问*ptr[10]和(*ptr)之间的差异[10]EN

回答 6

Stack Overflow用户

Stack Overflow用户

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问ptr[10]和(ptr)之间的差异[10]
EN