为了题目的准确性和我们一般学习过程中的习惯,这里所有的题目代码都是在 X86 环境(32 位平台)下运行的。

题目一:
#include <stdio.h> int main() { int a[5] = { 1, 2, 3, 4, 5 }; int* ptr =
(int*)(&a + 1); printf("%d,%d", *(a + 1), *(ptr - 1)); return 0; } //程序的结果输出什么?
我们先研究 ptr 指针变量里面存储的是什么。&a+1 表示取出整个地址并向后跳跃一个数组类型的大小,也就是指向了数组最后一个元素 5
的后面一块数组类型大小的空间。

但是我们想要把这个地址交给指针变量 ptr 是不行的,因为类型不一样(&a+1 是一个数组指针类型,prt 是一个整形指针类型),所以我们在 (&a+1)
之前 (int*) 来强制类型转换。这样我们搞清楚了 ptr 指针变量里存的是什么。

那么现在来看输出部分。*(a+1) 是比较简单的,a 是首元素地址,a+1 是第二个元素地址,对其解引用得到第二个元素 2 ,这是毋庸置疑的答案。对于
*(ptr-1) ,我们知道 ptr 里面存放的地址位置,并且知道ptr 是一个整形指针,ptr-1 相当于向前跳跃一个整形类型的大小,即指向数组最后一个元素
5 的位置。对其解引用就能得到元素 5 。

 

 故最后的输出结果为: 2,5 。

题目二:
#include <stdio.h> struct Test { int Num; char* pcName; short sDate; char
cha[2]; short sBa[4]; }*p; //如下表表达式的值分别为多少? //已知,结构体Test类型的变量大小是20个字节 int
main() { printf("%p\n", p + 0x1); printf("%p\n", (unsigned long)p + 0x1);
printf("%p\n", (unsigned int*)p + 0x1); return 0; } //程序最后输出什么?
我们注意观察结构体的定义,定义了一个结构体指针变量 p 。

p+0x1 非常简单,0x1 就是 1,只不过是以十六进制的格式书写的。这与我们经常习惯使用的指针计算一样,p 是一个结构体指针,那么 p+1
理当向后跳跃一个结构体类型的大小,即指向了结构体空间的后一个结构体空间的位置。并且我们知道 p 是一个全局变量,全局变量默认初始化为 0
,那我们便可以知道,p=0 ,p+1=20 。 而 %p 是一个十六进制的打印格式,所以结果输出:00000014 。

(unsigned long)p + 0x1 似乎更简单一些。p 类型转换成了一个长整形,那么就代表 p 不再是一个指针,它存放的 0
就是单纯意义上的数字。所以 0 + 0x1 就等于 00000001 。

(unsigned int*)p + 0x1 也非常简单。p 本是一个结构体指针,现在强转为整形指针,这就代表着 p 进行加减整数的时候步幅由 20 个字节
变成了 4 个字节。那么 p=0 ,p+1=4 是毋庸置疑的。输出的结果为:00000004 。

 题目三:
#include <stdio.h> 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 的分析与题目一没有区别,ptr1 存放的是数组最后一个元素的后面一块数组类型大小的地址。并且 ptr1 是一个整形指针。

ptr1[-1] 可改写成 *(ptr-1) ,因为我们曾经说过,只要是数组下标的操作都是指针操作,数组下标的操作只是指针操作的简写。那么此时
ptr1[-1] 就应该指向数组最后一个元素 4 并对其解引用得到输出结果00000004 。

(int*)((int)a+1) 如何理解呢?a 是数组名,那么它就指向了数组首元素的地址,再将其强制类型转换,那么 a 里面存放的地址就是单纯意义上的数字
,我们在这个数字的基础上 +1 ,然后再强制类型转换成整形指针并存放在 ptr2 中。也就是说,a 本是指向数组首元素的地址,(int)a+1 就代表地址数
+1 ,地址数 +1 就说明如果是指针的话,它就会指向后一个字节。再强转为整形指针,那么此时 ptr2 指向的地址为:

 

再对其解引用就能找到红色方块那块空间的内容,因为是小端存储,那么输出的结果是:02000000 。

需要注意的是,本题使用的打印格式为 %x ,正儿八经的十六进制,会省略有效数字前的 0 。

题目四:
#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; } //程序的结果输出什么?
首先我们注意观察,二维数组 a 里面存放的是三个逗号表达式,我相信有人会在这里踩坑。即三个逗号表达式,那么二维数组 a 里面的内容应该是 1,3,5
,0,0,0 (数组 a 有 6 个元素,内容不够后面自动补 0 )。

 

搞清了二维数组存放的是什么之后,我们来研究 a[0] 是什么。a[0] 是二维数组的第一个元素,这个元素是一个数组,也就是说,指针变量 p
存放的是二维数组中的第一个元素,这个元素是一个一维数组,即拿到了一个数组名。那么 p[0] 就很好理解了,p 是一个数组名,p[0] 就是数组的首元素,即 1
。故输出1 。

 

 

题目五:
#include <stdio.h> 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 存放了二维数组 a 的首元素地址,这就不难分析了,p 指向的数组与 a 数组的存储内容一样,但是内存分配不一样。

我们把这两个空间重叠在一起:

 可以看到,&p[4][2] 与 &a[4][2] 相差了 4 个元素,但因为 &p[4][2] 的地址位置比较低,所以两个相减是一个负数,即 -4
。但我们要以 %p 的形式打印,%p 是一个无符号的数,所以我们便得知结果应该是一个非常大的十六进制数。那么 -4 的原反补为:

所以前者的输出结果为:fffffffc 。

我们知道,指针(地址)相减,得到的是相差的元素个数,上面我们也讲过。那么 %d 是一个有符号的打印格式,所以输出的结果就是 -4 。

 

题目六:
#include <stdio.h> 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-1) 的结果为 10 应该没什么意见吧?

*(aa+1) 可改写成 aa[1] ,也就是二维数组的第二个元素,这个元素是一个一维数组,也就是说得到了一个数组名
。将这个数组名强转为整形指针存放在指针变量 ptr2 中,这时候就知道了 ptr2 的具体指向位置。(二维数组在内存空间中是连续存放的!)

*(ptr2-1) 就是将 ptr2 向前跳跃一个整形类型的大小,并解引用,即找到了元素 5 ,所以输出结果为 5 。 

题目七:
#include <stdio.h> int main() { char* a[] = { "work","at","alibaba" }; char**
pa = a; pa++; printf("%s\n", *pa); return 0; } //程序的结果输出什么?
指针数组 a 存放了三个字符串常量(关于字符串的常量在往期的博客中已经介绍过),使用二级指针 pa 来指向这个数组(char** pa=a;),这就表明
pa 变量存放的是 a 数组的首元素地址。pa++ 指向了数组的第二个元素,*pa 毋庸置疑得到了字符串常量 "at" 的首元素地址,再通过 %s
打印,就能的得到at 。

题目八:
#include <stdio.h> 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; } //程序的结果输出什么?
 我们先分析一下 c、cp、cpp 里面存放的是什么东西。指针数组 c 里面存放有四个字符串常量。指针数组 cp 里面存放的是四个字符串常量的地址。三级指针
cpp 存放的是 指针数组 cp 的首元素地址。那么草图可以画成:

 

**++cpp ,因为结合性的原因,我们要先计算 ++cpp,那么此时 cpp 指向 cp 的第二个元素的地址,然后解引用得到了 cp
中第二个元素,这个元素又是指向 c 的第三个元素,然后再解引用得到 c 的第三个元素,这个元素是字符串常量 "POINT" 的首字符地址,通过 %s
的形式打印得到POINT 。一定要注意,++ 这个操作是 cpp 参与运算了,所以下次运算时会从计算后的位置开始。

 *--*++cpp+3 ,还是先计算 ++cpp ,此时 cpp 指向 cp 的第三个元素的地址,然后解引用得到 c+1 ,然后 -- ,c+1 就变成了
c ,然后解引用得到 c 的首元素地址,在此地址的基础上 +3 ,就拿到了字符串常量 "ENTER" 的第四个字符的地址,然后通过 %s 的形式打印得到 ER


 *cpp[-2]+3 可改写为 *(*(cpp-2))+3 ,也就是说,此时 cpp 指向了 cp 的首元素地址,解引用得到了 c+3 ,c+3 是指向
c 的第四个元素的地址,解引用便得到了 c 的第四个元素,这个元素是字符串常量 "FIRST" 的首元素地址,在此地址的基础上 +3
便得到字符串常量第四个字符的地址,%s 通过这个地址打印便得到ST 。(此时 cpp 是没有实质运算的)

 cpp[-1][-1]+1 可改写为 *(*(cpp-1)-1)+1 ,此时 cpp 指向 cp 的第二个元素的地址,解引用得到 c+2 ,然后 -1
得到 c+1 ,即指向了 c 的第二个元素的地址,解引用便得到了 c 的第二个元素,这个元素是字符串常量 "NEW"  的首元素地址,然后 +1
便指向了字符串常量的第二个字符的地址,通过 %s 形式打印便得到了EW 。

 

 

技术
今日推荐
阅读数 399
阅读数 129
阅读数 115
阅读数 88
阅读数 69
阅读数 49
下载桌面版
GitHub
百度网盘(提取码:draw)
Gitee
云服务器优惠
阿里云优惠券
腾讯云优惠券
华为云优惠券
站点信息
问题反馈
邮箱:ixiaoyang8@qq.com
QQ群:766591547
关注微信