%90的人都会犯错的指针笔试题超详解

最新推荐文章于 2024-07-23 14:39:44 发布

灿烈♡

最新推荐文章于 2024-07-23 14:39:44 发布

阅读量79

点赞数 1

分类专栏： C语言文章标签： c语言经验分享 Powered by 金山文档

本文链接：https://blog.csdn.net/weixin_74269833/article/details/128610572

版权

C语言专栏收录该内容

22 篇文章 0 订阅

订阅专栏

指针笔试题

第一题：

int main()
{
  int a[5] = { 1, 2, 3, 4, 5 };
  int *ptr = (int *)(&a + 1);
  printf( "%d,%d", *(a + 1), *(ptr - 1));
  return 0;
}
//程序的结果是什么？

*(a+1)很简单，表示数组第二个元素；

对于ptr，&a是整个数组的地址，&a+1指针就会跳过整个数组指向数组后面的大小为20字节的空间，强制类型转换为int*后，ptr-1指针就会只向后移动一个int类型的大小，指向数组最后的元素。

所以结果是2，5

第二题：

struct Test
{
int Num;
char *pcName;
short sDate;
char cha[2];
short sBa[4];
}*p;
//假设p的值为0x100000。 如下表表达式的值分别为多少？
//已知，结构体Test类型的变量大小是20个字节
int main()
{
printf("%p\n", p + 0x1);//1
printf("%p\n", (unsigned long)p + 0x1);//2
printf("%p\n", (unsigned int*)p + 0x1);//3
return 0;
}

p是结构体指针，大小为20，指针+1跳过了20字节；

p被强制转化成无符号长整形，+1就相当于一个数字加1；

p被强制转换为整型指针，指针+1跳过了4字节。

结果为:

0x00100014

0x00100001

0x00100004

第三题：

int main()
{
//假设是小端存储
  int a[4] = { 1, 2, 3, 4 };
  int *ptr1 = (int *)(&a + 1);
  int *ptr2 = (int *)((int)a + 1);
  printf( "%x,%x", ptr1[-1], *ptr2);
  return 0;
}

与第一题类似，ptr1[-1]<-->*(ptr1-1)，ptr1指向数组后面的空间，ptr-1指向了数组的末元素；

将a强制转化为整型，+1后强制转化为整形指针，相当于指针向后移动了一个字节，在打印的时候，会连续打印从该地址开始连续四个字节的内容。

小端存储会将低字节位储存在低地址，数组的存储如图

结果为: 0x00000004,0x02000000

第四题：

#include <stdio.h>
int main()
{
  int a[3][2] = { (0, 1), (2, 3), (4, 5) };
  int *p;
  p = a[0];
  printf( "%d", p[0]);
return 0;
}

这道题很容易犯错，数组定义的大括号内是三个逗号表达式，因此数组的实际元素是{1,3,5,0,0,0}。p[0]表示二维数组第一个一维数组的首元素，结果是1。

第五题：

int main()
{
  int a[5][5];
  int(*p)[4];
  p = a;
  printf( "%p,%d\n", &p[4][2] - &a[4][2], &p[4][2] - &a[4][2]);
  return 0;
}

p[4][2]与a[4][2]相差4字节，相减的结果是-4，用地址打印出的是补码fffffffc

最后结果是：

fffffffc，-4

第六题：

int main()
{
  int aa[2][5] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
  int *ptr1 = (int *)(&aa + 1);
  int *ptr2 = (int *)(*(aa + 1));
  printf( "%d,%d", *(ptr1 - 1), *(ptr2 - 1));
  return 0;
}

ptr1指向二维数组后面的空间，被强制转换成int*后，-1向后退1个整型，*(ptr1 - 1)的结果是10。

aa是第一个一维数组的地址，p=*(aa+1)表示第二个一维数组首元素的地址，*(ptr2 - 1)的结果是5。

第七题：

#include <stdio.h>
int main()
{
char *a[] = {"work","at","alibaba"};
char**pa = a;
pa++;
printf("%s\n", *pa);
return 0;
}

结果为：at

第八题：

int main()
{
char *c[] = {"ENTER","NEW","POINT","FIRST"};
char**cp[] = {c+3,c+2,c+1,c};
char***cpp = cp;
printf("%s\n", **++cpp);
printf("%s\n", *--*++cpp+3);
printf("%s\n", *cpp[-2]+3);
printf("%s\n", cpp[-1][-1]+1);
return 0;
}

初始存储结构

**++cpp

*--*++cpp+3

*cpp[-2]+3

cpp[-1][-1]+1

结果是：

POINT

二维数组

要求：说出sizeof具体是求什么的大小，并写出结果

int a[3][3] = {0};
printf("%d\n",sizeof(a));//1
printf("%d\n",sizeof(a[0][0]));//2
printf("%d\n",sizeof(a[0]));//3
printf("%d\n",sizeof(a[0]+1));//4
printf("%d\n",sizeof(*(a[0]+1)));//5
printf("%d\n",sizeof(a+1));//6
printf("%d\n",sizeof(*(a+1)));//7
printf("%d\n",sizeof(&a[0]+1));//8
printf("%d\n",sizeof(*(&a[0]+1)));//9
printf("%d\n",sizeof(*a));//10
printf("%d\n",sizeof(a[3]));//11

解析：

sizeof(数组名)表示整个数组的大小，结果是36

表示二维数组中第一个数组的首元素，大小为4

a[0]是二维数组中第一个一维数组的数组名，sizeof(a[0])表示这个一维数组的大小，结果是12

a[0]是二维数组中第一个一维数组的数组名，数组名表示数组首元素的地址，a[0]+1表示该一维数组第二个元素的地址，大小为4/8

*(a[0]+1)表示第一个一维数组的第二个元素，大小为4

a表示二维数组首元素的地址，a+1表示二维数组第二个一维数组的地址，大小是4/8

*(a+1)表示二维数组第二个一维数组，sizeof(数组名)表示该一维数组的大小，结果是12

&a[0]+1<-->&*(a+0)+1<-->a+1,化简后与第6题相同

*(&a[0]+1)<-->*(a+1),结果与第7题相同

*a，表示二维数组的首元素，即第一个一维数组，sizeof(*a)表示一维数组的大小，结果是9

a[3]虽然未定义，但是依然可以计算，其结果与sizeof(a[0]) 、sizeof(a[1]) 、sizeof(a[2])无异，结果是12

如果上面这道题理解起来有点困难，别着急，下面我们从最基础的一维数组开始理解。

数组名的意义

1. sizeof(数组名)，这里的数组名表示整个数组，计算的是整个数组的大小。（）必须单独放数组名才可以表示整个数组，比如（arr+0）就不能这样认为。

2. &数组名，这里的数组名表示整个数组，取出的是整个数组的地址。

3. 除此之外所有的数组名都表示首元素的地址。

一维数组

int a[] = {1,2,3,4};

printf("%d\n",sizeof(a));

sizeof(数组名)表示整个数组的大小，a有4个元素每个元素4字节，结果是16

printf("%d\n",sizeof(a+0));

()没有单独放数组名，表示的是数组首元素的地址，大小为4/8

printf("%d\n",sizeof(*a));

对数组首元素的地址解引用，表示数组首元素大小，结果为4

printf("%d\n",sizeof(a+1));

表示数组第二个元素的地址，大小为4/8

printf("%d\n",sizeof(a[1]));

a[1]<---->*(a+1)，表示数组第二个元素，大小为4

printf("%d\n",sizeof(&a));

&数组名表示整个数组的地址，类型为数组指针 int (*)[4]，指针的大小都是4/8

printf("%d\n",sizeof(*&a));

&a表示整个数组的地址，对它解引用表示整个数组，结果为16（也可以理解为：*&可以抵消，相当sizeof(a)

printf("%d\n",sizeof(&a+1));

&a表示整个数组的地址，+1就跳过整个数组，指向数组后面的大小为16的空间，但本质还是指针，结果是4/8

printf("%d\n",sizeof(&a[0]));

a[0]表示数组首元素，&a[0]表示数组首元素的地址，大小为4/8(&a[0]<--->&*(a+0)<--->a)

printf("%d\n",sizeof(&a[0]+1));

&a[0]表示数组首元素的地址,+1就是数组第二个元素的地址，大小为4/8

字符数组

<1>

char arr[] = {'a','b','c','d','e','f'};

printf("%d\n", sizeof(arr));

sizeof(数组名)表示整个数组的大小，结果是6

printf("%d\n", sizeof(arr+0));

数组名没有单独放在()中，表示数组首元素的地址，大小是4/8

printf("%d\n", sizeof(*arr));

表示数组首元素的大小，结果是1

printf("%d\n", sizeof(arr[1]));

表示数组第二个元素的大小，结果是1

printf("%d\n", sizeof(&arr));

&数组名表示整个数组的地址，大小是4/8

printf("%d\n", sizeof(&arr+1));

数组地址+1，表示指针指向数组后面的大小为6的空间，结果为4/8

printf("%d\n", sizeof(&arr[0]+1));

&arr[0]表示数组首元素地址，+1变成第二个元素的地址，大小为4/8

printf("%d\n", strlen(arr));

数组最后一个元素不是'\0'，后面的空间存储未知内容，所以不知道什么时候会遇到'\0'停止，结果是随机值

printf("%d\n", strlen(arr+0));

数组最后一个元素不是'\0'，后面的空间存储未知内容，所以不知道什么时候会遇到'\0'停止，结果是随机值

printf("%d\n", strlen(*arr));

*arr是数组首元素，对应的ASC码是97，表示从地址为0x00000061（不可访问）的内存开始访问，直到遇到'\0'结束，因为地址不可访问，会报错。

printf("%d\n", strlen(arr[1]));

arr[1]表示数组第二个元素，b的ASC码是98，表示从地址为0x00000062（不可访问）的内存开始访问，直到遇到'\0'结束，因为地址不可访问，会报错。

printf("%d\n", strlen(&arr));

&arr表示数组的地址，数组的地址和数组首元素地址大小相同，从首元素开始，由于数组最后一个元素不是'\0'，后面的空间存储未知内容，所以不知道什么时候会遇到'\0'停止，结果是随机值

printf("%d\n", strlen(&arr+1));

&arr+1表示一个指针指向数组后面的大小为6的空间，这个指针和数组后面第一个元素的地址大小相同，从这个元素开始，因为数组后面的内存未初始化，不知道什么时候遇到'\0'结束，结果随机

printf("%d\n", strlen(&arr[0]+1));

&arr[0]表示数组首元素的地址，+1表示第二个元素的地址，strlen从第二个元素开始计算，由于数组最后一个元素不是'\0'，后面的空间存储未知内容，所以不知道什么时候会遇到'\0'停止，结果是随机值

<2>

char arr[] = "abcdef";

printf("%d\n", sizeof(arr));

表示整个数组的大小，数组中包含abcdef和'\0'，结果是7

printf("%d\n", sizeof(arr+0));

数组名没有单独放在()中，表示数组首元素的地址，大小是4/8

printf("%d\n", sizeof(*arr));

表示数组首元素的大小，结果是1

printf("%d\n", sizeof(arr[1]));

表示数组第二个元素的大小，结果是1

printf("%d\n", sizeof(&arr));

&数组名表示整个数组的地址，大小是4/8

printf("%d\n", sizeof(&arr+1));

数组地址+1，表示指针指向数组后面的大小为7的空间，结果为4/8

printf("%d\n", sizeof(&arr[0]+1));

&arr[0]表示数组首元素地址，+1变成第二个元素的地址，大小为4/8

printf("%d\n", strlen(arr));

arr表示数组首元素地址，数组最后一个元素是'\0'，strlen计算从首元素之后，'\0'之前的元素个数，结果是6

printf("%d\n", strlen(arr+0));

arr+0表示数组首元素地址，数组最后一个元素是'\0'，strlen计算从首元素之后，'\0'之前的元素个数，结果是6

printf("%d\n", strlen(*arr));

*arr是数组首元素，对应的ASC码是97，表示从地址为0x00000061（不可访问）的内存开始访问，直到遇到'\0'结束，因为地址不可访问，会报错。

printf("%d\n", strlen(arr[1]));

arr[1]表示数组第二个元素，b的ASC码是98，表示从地址为0x00000062（不可访问）的内存开始访问，直到遇到'\0'结束，因为地址不可访问，会报错。

printf("%d\n", strlen(&arr));

&arr表示数组的地址，数组的地址和数组首元素地址大小相同，strlen计算从首元素之后，'\0'之前的元素个数，结果是6

printf("%d\n", strlen(&arr+1));

printf("%d\n", strlen(&arr[0]+1));

&arr[0]表示数组首元素的地址，+1表示第二个元素的地址，strlen从第二个元素开始计算，直到遇到第7个元素'\0',结果是5

<3>

char *p = "abcdef";

printf("%d\n", sizeof(p));

这里的p不是数组名，只是单纯的指针指向字符串的首字符，大小时4/8

printf("%d\n", sizeof(p+1));

表示字符串第二个字符的地址，结果是4/8

printf("%d\n", sizeof(*p));

表示字符串首字符的大小，结果为1

printf("%d\n", sizeof(p[0]));

p[0]<--->*(p+0)，表示首字符的大小，结果为1

printf("%d\n", sizeof(&p));

表示指针p的地址，类型为二级指针char**，大小为4/8

printf("%d\n", sizeof(&p+1));

表示指向p的地址的下一个地址，即pp+1，大小为4/8

printf("%d\n", sizeof(&p[0]+1));

&p[0]+1<--->&*(p+0)+1<--->p+1,表示字符串第二个字符的地址，大小为4/8

printf("%d\n", strlen(p));

strlen从首字符开始，因为字符串的末字符不是'\0'，字符串后面的空间未初始化，不知道什么时候遇到'\0'，结果是随机值

printf("%d\n", strlen(p+1));

strlen从第二个字符开始，因为字符串的末字符不是'\0'，字符串后面的空间未初始化，不知道什么时候遇到'\0'，结果是随机值

printf("%d\n", strlen(*p));

*p是字符串首字符a，对应的ASC码是97，表示从地址为0x00000061（不可访问）的内存开始访问，直到遇到'\0'结束，因为地址不可访问，会报错。

printf("%d\n", strlen(p[0]));

p[0]是字符串首字符a，对应的ASC码是97，表示从地址为0x00000061（不可访问）的内存开始访问，直到遇到'\0'结束，因为地址不可访问，会报错。

printf("%d\n", strlen(&p));

&p表示指针p的地址，由于p后面的空间未知，不知道什么时候遇到'\0'，结果是随机值

printf("%d\n", strlen(&p+1));

&p+1指向未知区域，区域也未初始化，strlen结果为随机值

printf("%d\n", strlen(&p[0]+1));

&p[0]+1<--->&*(p+0)+1<--->p+1,表示字符串第二个字符的地址，strlen从第二个字符开始，因为字符串的末字符不是'\0'，字符串后面的空间未初始化，不知道什么时候遇到'\0'，结果是随机值

灿烈♡

关注

1
点赞
踩
2

收藏

觉得还不错? 一键收藏
0
评论
%90的人都会犯错的指针笔试题超详解

%90的人都会犯错的指针面试题
复制链接

扫一扫

专栏目录