十二.指针详解（五）

指针

1.求代码结果

#define _CRT_SECURE_NO_WARNINGS
#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;
}

运行结果：2，5

解析

2：在a+1中的a是首元素地址，+1就是第二个元素的地址，也就是2的地址，再解引用就是2

5：&a+1是整个数组的地址+1，会跳过一个数组，指针指向5的后面，但是ptr是整型指针，所以强转之后ptr会指向5

-- -- -- -- -- -- -- -- -- --

2.求代码结果

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
struct Test
{
	int num;
	char* pcName;
	short sDate;
	char cha[2];
	short sBa[4];
}*p;
//假设p的值为0x100000，如下表达式的值分别为多少
//已知结构体Text类型的变量大小为20个字节
int main()
{
	p = (struct Text*)0x100000;
	printf("%p\n", p + 0x1);
	printf("%p\n", (unsigned long)p + 0x1);
	printf("%p\n", (unsigned int*)p + 0x1);
	return 0;
}

运行结果：

00100014
00100001
00100004①

解析

00100014：指针+1是跳过一个结构体（20字节），0x14就是十进制的20

00100001：p中的地址强制类型转换成长整型1048576（0x100000），+1就是1048577（0x100001），打印地址，再次转换成十六进制，输出00100001

00100004：无符号整型指针是4个字节，+1跳过四个字节

-- -- -- -- -- -- -- -- -- --

3.计算代码结果

#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;
}

运行结果：4,2000000

解析

4：ptr1可以看成*(ptr1+(-1))，ptr1又是数组的地址+1，即指向4的后面，-1再解引用即为4（int*类型-1跳过4个字节）

2000000：②

-- -- -- -- -- -- -- -- -- --

4.计算代码结果

#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

解析：二维数组初始化时使用了逗号表达式，实际初始化的时1，3，5。a[0]中a是第一行的数组名，即1的地址。p[0]等于*(p+0)，即为1

-- -- -- -- -- -- -- -- -- --

5.计算代码结果

#include<stdio.h>
int main()
{
	int a[5][5];
	int(*p)[4];
    p = a;//这样写可能会报错，那就需要再强转一下
	      //p = (int(*)[4])a;
	printf("%p,%d\n", &p[4][2] - &a[4][2], &p[4][2] - &a[4][2]);
	return 0;
}

运行结果：FFFFFFFFFFFFFFFC,-4

解析

- 4：1000 0000 0000 0000 0000 0000 0000 0100（原码）

        1111 1111 1111 1111 1111 1111 1111 1100（补码）

每四个1就是一个15，对应十六进制的一个F（64位平台上F会多一点）

1100就是12，对应十六进制的C

-- -- -- -- -- -- -- -- -- --

6.计算代码结果

#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;

运行结果：10,5

解析

10：&aa+1，指针ptr1跳过一整个二维数组，指在10的后面，打印时作为整型指针-1指向10，解引用找10

5：aa是第一行地址，+1指向第二行地址（指向6的位置）

-- -- -- -- -- -- -- -- -- --

7.计算代码结果

#include <stdio.h>
int main()
{
	char* a[] = { "work","at","alibaba" };
	char** pa = a;
//如果前两行报错的话就在前面都加上const
	pa++;
	printf("%s\n", *pa);
	return 0;
}

运行结果：at

解析

数组里是三个常量字符串的首字符地址，a是首元素地址（w的地址），并放在二级指针pa*中

pa++即pa+1，pa(char**)是一个指向char*的常量，+1跳过一个char*指向下一个char*

则pa解引用一次就拿到了at中a的地址，以a的地址为开头打印字符串即可得到at

-- -- -- -- -- -- -- -- -- --

8.计算代码结果

#include <stdio.h>
int main()
{
	const char* c[] = { "ENTER","NEW","POINT","FIRST" };
	const char** cp[] = { c + 3,c + 2,c + 1,c };
	const 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;
}

运行结果：

POINT

ER

ST

EW

解析

POINT：先执行自加运算，cpp变成c+2的地址，解引用一次，拿到c+2（第三个char*的地址），再解引用一次拿到内容——字符P的地址，以%s的形式输出，最后打印POINT

ER：上一条语句cpp已经指向c+2。再次自加会指向c+1，解引用一次拿到c+1，自减变成c（第一个char*的地址，再解引用拿到内容——字符E的地址，+3变成第三个E的地址，最后打印ER

ST：上一条语句cpp指向c+1。*cpp[-2] + 3 = **(cpp - 2) + 3，cpp - 2指向c+3（cpp的值不会改变，c+3是这个cpp - 2 表达式的值），再解引用的一次，拿到c + 3（第四个char*），再解引用拿到内容——字符F的地址

EW：上一条语句cpp指向c+1。cpp[-1][-1] = *(*cpp - 1) - 1)，cpp - 1指向c+2，解引用一次拿到c+2，再减1变成c+1（第二个char*），再解引用拿到内容——字符N的地址，+1变成E的地址，所以最后从E开始打印，输出EW

-- -- -- -- -- -- -- -- -- -- -- -- -- -- ---- -- -- -- -- -- -- -- -- -- -- -- -- -- --

附

①这个结果是在32位平台上跑出来的，如果换成64位平台，由于指针长度不同结果就不是这样了

②和上一题一样，如果在x64平台上，由于指针变成8个字节，ptr2是无法成功访问了，所以也是运行不了的