C语言-指针就那么回事

通过以下7道例题的剖析，你对指针的理解将会炉火纯青！！！

 //已知结构体的大小是20个字节
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);//0x100014
 printf("%p\n", (unsigned long)p + 0x1);//0x100001
 printf("%p\n", (unsigned int*)p + 0x1);//0x100004
 return 0;
 }

 printf("%p\n", p + 0x1);//0x100014

p是结构体指针大小是20个字节，那么p+1就是跳过20个字节，又因为是是十六进制，所以结果是0x100014
 printf("%p\n", (unsigned long)p + 0x1);//0x100001

首先p被强制类型转换成了unsigned long，那么0x100000就是一个整数，那么+1就是+1，所以结果是0x100001
 printf("%p\n", (unsigned int*)p + 0x1);//0x100004

首先p被强制类型转换成了unsigned int*，p就是一个整形指针，+1自然跳过4个字节，所以结果是0x100004

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);//ptr1[-1]就是*(ptr1+(-1))==*(ptr1-1)
 return 0;
 }

ptr1[-1]

（1）对于&a，取出的是数组的地址，+1相当于跳过了整个数组

（2）ptr1[-1] = *(ptr1-1),访问的是数组的第四个元素4

*ptr2

（1）(int)a，a表示首元素的地址，被强制类型转换为int，此时我们应该了解大端字节序与小端字节序这个知识点

大端字节序：把数据的低位字节序的内容存放在高地址处，高位字节序的内容存放在低地址处

小端字节序：把数据的低位字节序的内容存放在低地址处，高位字节序的内容存放

vs环境是小端存储，所以1在内存中的存储就如上图所示

（2）(int)a+1，便访问01之后的00

（3） (int *)((int)a + 1)，ptr2就是一个整形指针，访问四个字节的内容，则是00 00 00 02

因此结果便是0x2000000，篮框框实际就是0x2000000

#include <stdio.h>
 int main()
 {
 int a[3][2] = { (0, 1), (2, 3), (4, 5) };//(0, 1)是逗号表达式结果是1
 int *p;
 p = a[0];
 printf( "%d", p[0]);//1
 return 0;
 }

 

p[0]

（1）p = a[0]，表示二维数组第一行的一维数组的数组名，即第一行的一维数组的地址

（2）p[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;
 }

 

（1）p = a，a是二维数组数组名表示数组第一行的一维数组的数组地址，p是一个指向int [4]的数组指针，这条语句会出现类型不匹配，但是a它仍然是一个地址，p是一个指针，它仍然是可以放进去的

（2） &p[4][2]，由于p是一个指向int [4]的数组指针，那么一次只能跳过四个字节所以p[4][2]的位置如上所示，a[4][2]的位置如上所示

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));//10   5
 return 0;
 }

 

*(ptr1 - 1)

（1）(&aa + 1)，&aa取出的是整个数组的地址，那么+1自然会跳过整个数组位置如上所示

（2）(int *)(&aa + 1)，被强制类型转换为（int*）

（3）*(ptr1 - 1)，在&aa + 1的位置上向后跳4个字节,解引用自然访问的是10

*(ptr2 - 1)

（1）*(aa + 1) = aa[1]，aa表示是二维数组数组名表示数组第一行的一维数组的数组地址，+1跳过的是一个一维数组的大小，位置如上所示，相当于是二维数组第二行一维数组的地址

（2） (int *)(*(aa + 1))，强制类型转换为整形指针
（3）*(ptr2 - 1)，-1自然后跳4个字节，访问的是5

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

 

（1）char**pa = a，表示数组的第一个元素的地址传给pa

（2）pa++，表示pa指向数组的第二个元素的地址

（3）*pa，此时*pa找到了数组的第二个元素，即"at"中a的地址，按字符串打印即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;
 }

  printf("%s\n", **++cpp)

（1）cpp中存放的是c+3的地址

（2）++cpp，地址+1那么存放的是c+2的地址

（3）*++cpp，找到了cp中的第二个元素的内容，即c的第三个元素的地址

（4）**++cpp，找到了"POINT"中P的地址

（5）按字符串进行打印，所以结果是POINT

  printf("%s\n", *--*++cpp+3)

（1）cpp中存放的是c+2的地址

（2）++cpp，地址+1那么存放的是c+1的地址（++优先级高于+）

（3）*++cpp，找到了cp中的第三个元素的内容，即c的第二个元素的地址（*的优先级高于+）

（4）--*++cpp，cp中的第三个元素的内容变换成了c的第一个元素的地址（--优先级高于+）

（5）*--*++cpp，找到了"ENTER"中E的地址

（6）*--*++cpp+3，E的地址+3便是ER中的E的地址

（7）按字符串进行打印，所以结果是ER

 printf("%s\n", *cpp[-2]+3)

（1）cpp中存放的是cp中的第三个元素c的地址

（2）cpp[-2]=*(cpp-2)，找到了cp中的第一个元素的内容，即c的第四个元素的地址

（3）*cpp[-2]=**(cpp-2)，找到了''FIRST"中F的地址

（4）*cpp[-2]+3，F的地址+3便是S的地址

（5）按字符串打印，所以结果是ST

 printf("%s\n", cpp[-1][-1]+1)

（1）cpp中存放的是cp中的第三个元素c的地址

（2）cpp[-1]=*(cpp-1)，找到了cp中的第二个元素的内容，即c的第二个元素的地址

（3）cpp[-1][-1]=*(*(cpp-1)-1)，找到了''NEW"中N的地址

（4）cpp[-1][-1]+1，N的地址+1便是E的地址

（5）按字符串打印，所以结果是EW