首页 > 试题广场 >

请选择下列程序的输出结果是（）

[单选题]

请选择下列程序的输出结果是（）

#include <stdio.h>
int main() {
    const int N = 10;
    const int M = 2;
    int *a = new int[N];
    for (int i = 0; i < N; ++i)
        a[i] = (0 == i % 2) ? (i + 2) : (i + 0);
    int(*b)[N / M] = (int(*)[N / M]) a;
    for (int i = 0; i < M; ++i)
        for (int j = 0; j < N / M; ++j)
            printf("%d", b[i][j]);
    return 0;
}

```
21436587109
```
```
224466881010
```
```
03254769811
```
```
21436687101
```

查看正确选项

。。221

for(inti=0;i<N;++i)
        a[i]=(0==i%2)?(i+2):(i+0);

结果为
[2,1,4,3,6,5,8,7,10,9]

int (*b)[N/M]=(int (*)[N/M])a;
//int (*b)[5]=(int (*)[5])a;

b是数组指针,数组指针是指向一大块内存
现在对于b,数据是这样的

[[2,1,4,3,6],[5,8,7,10,9]]
//b[0]-->[2,1,4,3,6]
//b[1]-->[5,8,7,10,9]

//顺序打印
for(int i=0;i<M;++i)
        for(int j=0;j<N/M;++j)
            printf(“%d”,b[i][j]);

编辑于 2017-09-13 09:30:28 回复(3)

笨笨的程序猿

int a[] = {2,1,4,3,6,5,8,7,10,9}; //一维数组a

int (*b)[N/M]=(int (*)[N/M])a; //将一维数组a强制转化为数组指针并赋值给数组指针b；

//上面两句可以拆分为以下几句理解；

int a[2][N/M] = {2,1,4,3,6,5,8,7,10,9};

int (*b)[N/M]; //b是数组指针，指向具有N/M个元素的一维数组；

b = a;

发表于 2017-08-29 10:38:30 回复(4)

大黑熊

A
int (*b)[N / M] = ( int (*)[N / M])a; ==> int (*b)[5] = ( int (*)[5])a;

b 为指向 a 的前五个元素

但是输出的时候，第二层外循环越界输出 a 后五个元素

#pragma warning(disable:4996)
#include <stdio.h>
int main(){
	const int N = 10;
	const int M = 2;
	int* a = new int[N];
	for (int i = 0; i < N; ++i)
		a[i] = (0 == i % 2) ? (i + 2) : (i + 0);
	int(*b)[N / M] = (int(*)[N / M])a;
	for (int i = 0; i < M; ++i)
	for (int j = 0; j < N / M; ++j)
		printf("%d", b[i][j]);
	return 0;
}

发表于 2017-04-03 12:27:17 回复(5)

201903071953912

容易知道a[] = {2,1,4,3,6,5,8,7,10.9}

关键是理解：int (*b)[N/M]=(int (*)[N/M])a;

首先 b[N/M]是 b[5] ，由数组和指针关系（百度）可知 *b 是 b[ ] ，那么 (*b)[N/M] 就是 b[ ][N/M] ，int (*b)[N/M] 就是 int b[ ][5] 。

然后看 (int (*)[N/M])a ，其中 (int (*)[N/M]) 应该是类型强转，把 a[ ] 强转为 a[ ][N/M] ，因为 (*)[N/M] 可理解为 [ ][N/M] 。

最后

int b[ ][5] = (int [ ][5])a;

发表于 2019-03-09 16:43:43 回复(0)

大星星和小猩猩

这道题难在于：int (*b)[N/M]=(int (*)[N/M])a;

int * arr[5] -- 指针数组, 表示这个数组长度为5, 里面装的int* ；

int (*arr)[5] -- 表示这是一个数组指针,也就是指向一个长度为5的数组，一般常用来表示二维数组的行指针；

int (&rArr)[5] -- 数组的引用。

编辑于 2017-11-16 15:49:50 回复(0)

安大爷写代码

不能理解这句话在做怎样的操作，有大神给个解析吗？

int (*b)(N/M)=(int (*)[N/M])a;

发表于 2017-08-20 11:26:22 回复(4)

zhyn456128

int(*b)(N/M)=(int(*)[N/M])a; 题目给的是扯淡吗？明明是
int(*b)[N/M]=(int(*)[N/M])a;

发表于 2017-09-03 15:50:10 回复(2)

于小咸

这道题需要注意的是指针的类型，a是指向整数的指针，b是指向长度为5的整型数组的指针，因此a+1和b+1指向的对象不同，如下面表示。

  a  a+1 a+2   ...   a+5   ...
| 2 | 1 | 4 | 3 | 6 | 5 | 8 | 7 | 10 | 9 |
  b                  b+1   ...

首先定义整型指针a，指向一个整型变量，根据指针和数组的运算规则，有*(a+i)=a[i]，经过for循环赋值，数组成员如下

{2,1,4,3,6,5,8,7,10,9}

下面这条表达式是本题的关键，左式定义b为数组指针，指向长度为5的数组，因为数组本身是指针表示的，因此b是指向指针的指针。右式为强制类型转换，将指针a转换为长度为5的数组指针。

int(*b)[N / M] = (int(*)[N / M])a;

根据指针和数组的运算规则，此时满足*(b+i)=b[i]=(int *[5])*(a+i*5)，由于*(b+i)=b[i]，尽管对b赋值时用的是数组a的前5项，但通过b+1可以访问a的后5项。

编辑于 2018-04-28 15:45:27 回复(1)

东方小小小小小虾米

#pragma warning(disable:4996)
#include <stdio.h>
int main(){
    const int N = 10;
    const int M = 2;
    int* a = new int[N];  #指针a指向数组的起始地址，即int a[N]
    for (int i = 0; i < N; ++i)
        a[i] = (0 == i % 2) ? (i + 2) : (i + 0); #a={2,1,4,3,6,5,8,7,10,9}
    int(*b)[N / M] = (int(*)[N / M])a; 
    #拆分来看：
    #int(*b)[N / M] 声明了一个数组指针b,指向的是大小为N/M的数组。
    #(int(*)[N / M])a 强制转换了数组a起始地址的指针类型（原来是指向大小为10的数组，现变成指向大小为N/M的数组）。
    # = 号即把转换了的数组a起始地址赋值给指针b。
    for (int i = 0; i < M; ++i)
    for (int j = 0; j < N / M; ++j)
        printf("%d", b[i][j]);   #b[0][j]=*(b[0]+j) = *(a+j)= a[j] 
                                 #b[1][j]=*(b[1]+j）= *(a+5+j)= a[5+j] 
                                 #b[2][j]=*(b[2]+j) = *(a+10+j)= a[10+j]
                                                ...
    return 0;
}

考的是指针指向地址的变换

编辑于 2019-04-06 15:59:43 回复(0)

杉杉来啦

容易知道a[] = {2,1,4,3,6,5,8,7,10.9}

关键是理解：int (*b)[N/M]=(int (*)[N/M])a;

首先 b[N/M]是 b[5] ，由数组和指针关系（百度）可知 *b 是 b[ ] ，那么 (*b)[N/M] 就是 b[ ][N/M] ，int (*b)[N/M] 就是 int b[ ][5] 。

然后看 (int (*)[N/M])a ，其中 (int (*)[N/M]) 应该是类型强转，把 a[ ] 强转为 a[ ][N/M] ，因为 (*)[N/M] 可理解为 [ ][N/M] 。

最后

int b[ ][5] = (int [ ][5])a;

数组指针相当于二维数组的行指针

发表于 2020-03-01 21:02:50 回复(0)

蜡笔D王子

这个题有个隐含条件，int (*a)[ ][5]=int (*b)[5],其中a的大小不会改变还是new的10个int大小，提干后边是将a缩小为5个一组，那么a就会变成二维数组，就会变成a[2][5]，这里考的是二维数组，int(*b)[N/M]=(int(*)[N/M])a这步是类型转换

发表于 2018-09-27 19:05:33 回复(0)

奚越

for(int i=0;i<N;++i)

a[i]=(0==i%2)?(i+2):(i+0);

// a是一个指针，指向含有{2,1,4,3,6,5,8,7,10,9}十个元素的数组

int (*b)[N/M]=(int (*)[N/M])a;

// int (*b)[5]=(int (*)[5])a;

// 强制类型转换，其中将a转换为：一个指针，这个指针指向含有5个int类型的数组。b也是这种类型，所以b与a的首地址一样，但是b+1的步长 //是int[5]，所以b[0]是前五个，b[1]是接下来的五个，b[2,3,4,...]溢出，指向未知的内容

发表于 2018-01-18 11:50:18 回复(0)

城枫墨凉

package binarySearch;

public class JavaAnalysis {

    public static void main(String[] args) {

        int N = 10;
        int M = 2;
        int [] a = new int [N]; //初始化长度为10的一维数组a[10]
        int [][] b = new int[M][N/M];//初始化二维数组b[2][5]
        int Len = N/M;
        for(int i=0;i<N;i++)
        {
            a[i]=(i%2==0)?(i+2):(i+0);//为数组a赋值
        }

        for(int x=0,y=0;y<Len;y++)
        {
             b[x][y]=a[y];
             //用数组a的前五位元素a[0]-a[4]为二维数组b[0][0]-b[0][4]赋值
        }
        for(int x=1,y=0,z=Len;y<Len&&z<a.length;y++,z++)
        {
                b[x][y]=a[z];
                //用数组a的后五位元素a[5]-a[9]为二维数组b[1][0]-b[1][4]赋值
        }
     for(int i=0;i<M;i++)
     {
          for(int j=0;j<N/M;j++)
          {
              System.out.print(b[i][j]);
              //循环打印b[0][0]-b[0][4]和b[1][0]-b[1][4]
          }
     }
    }

}

答案为:A

发表于 2018-01-12 11:47:45 回复(0)

暴走的五花肉

int (*b)[N/M] = int(*)[N/M]a //就等价于 int b [][N/M] = int a [][N/M]

把一维数组强制转换成二维数组,然后b和他一毛一样

发表于 2023-09-07 10:37:27 回复(0)

恐高宇航员

new改为malloc
int* a = (int*)malloc(N * sizeof(int));：使用malloc函数在堆上动态分配了N个整型变量的内存空间，并将其地址赋值给指针a。需要注意的是，由于malloc函数返回的是void*类型的指针，需要将其显式地转换为int*类型。
if (a == NULL) { printf("内存分配失败\n"); return 1; }：对内存分配的结果进行错误检查，如果分配失败，则输出错误信息并返回非零值表示程序异常退出。
for (int i = 0; i < N; ++i) a[i] = (0 == i % 2) ? (i + 2) : (i + 0);：使用循环对动态分配的内存空间进行赋值操作，其中根据索引i的奇偶性选择不同的赋值方式。
int (*b)[N / M] = (int(*)[N / M])a;：将数组指针b指向了被强制类型转化后的指针a，其中每行的元素个数为N / M。
for (int i = 0; i < M; ++i) for (int j = 0; j < N / M; ++j) printf("%d", b[i][j]);：使用嵌套循环遍历二维数组，并通过printf函数打印输出数组的元素。
free(a);：使用free函数释放动态分配的内存空间，避免内存泄漏。

发表于 2023-04-13 23:15:32 回复(0)

MisteryAstron

int (*b)(N/M)=(int(*)[N/MI)a;这里是把a数组强制转换成数组指针类型

发表于 2022-03-26 14:20:22 回复(0)

小白-l

int (*b)[5] ：括号的优先级高于[]，所以是一个数组指针，数组的大小是5，b指向这个数组？

发表于 2021-03-21 15:39:24 回复(0)

hwzub

int (*b)[N/M]=(int (*)[N/M])a;

化简后即为：int (*b)[5]=(int (*)[5])a;

左侧：int (*b)[5]；(*b)说明b是一个指针，指向含有5个int变量的数组。

右侧：(int (*)[5])a对比(int)a进行理解，说明a是被强制类型转换为(int (*)[5])类型，即一个指针，指向含有5个int变量的数组。

编辑于 2020-08-29 08:52:18 回复(0)

民兵王二蛋

如果列数是10的化，

二维数组b[10][10]=b[10*10+10]；

发表于 2020-08-07 17:19:21 回复(0)

在水一方有人占用？！

a[10];

int (*b)[5]=(i ])a;

将一维数组强转为二维数组，要记住这个方法

发表于 2019-08-30 19:44:30 回复(0)

提交观点

问题信息

C语言

来自：腾讯2017校招开发工...

上传者：牛100

难度：

28条回答 1266收藏 6229浏览

请选择下列程序的输出结果是（）

问题信息

热门推荐

相关试题