【C语言】——指针八：指针运算笔试题解析

【C语言】——指针八：指针运算笔试题解析

- 一、题一
- 二、题二
- 三、题三
- 四、题四
- 五、题五
- 六、题六
- 七、题七
  一、题一
```
//程序输出结果是什么
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 - 1)。
  - 先来看 &a。对数组名进行取地址操作，取出的是整个数组的地址，虽然数值上与数组首元素相等，但他们是不同的类型。在这里，它类型为 i n t （ ∗ ） [ 5 ] int（*）[5] int（∗）[5]。
  - 再看 &a + 1 ，这里取出的是整个数组的地址，+1 即跳过整个数组。最后，再强制类型转换成 i n t int int * 类型
  - ptr - 1 此时，指针已经跳过了整个数组，因为此时的 p t r ptr ptr 已经是 i n t int int* 类型， - 1，后退 4 个字节，即指向数组最后一个元素。
  - *(ptr - 1) 最后再进行解引用，取出数组最后一个元素
    运行结果：
    
    二、题二
```
//在x86环境下
//假设结构体大小20字节
//程序输出结果是啥
struct Test
{int Num;
	char* pcName;
	short sDate;
	char cha[3];
	short sBa[4];
}*p = (struct Test*)0x100000;
int main()
{printf("%p\n", p + 0x1);
	printf("%p\n", (unsigned long)p + 0x1);
	printf("%p\n", (unsigned int*)p + 0x1);
	return 0;
}
```
    - 首先我们来理解(定义的结构体类型)*p = (struct Test*)0x100000; 什么意思呢？即定义了一个结构体类型，创建了该类型的指针变量 p p p 。同时，将0x100000这个十六进制数强制类型转换成该结构体指针类型（整数默认 i n t int int 类型）后，将其赋值指针变量 p p p 。
    - printf("%p\n", p + 0x1); 指针类型 +1，跳过的是该指针所指向元素的类型的大小个字节。这里定义的结构体大小为 20 字节，即跳过 20 字节，因为是十六进制表示，即：0x100000 + 0x14，答案：0x100014
    - printf("%p\n", (unsigned long)p + 0x1); 第二个 p r i n t f printf printf 语句，先将 p p p 强制类型转换成 u n s i g n e d unsigned unsigned l o n g long long 类型，此时0x100000 仅仅是一个普通的数字而已，再加 0x1，是单纯的数学上的相加。答案：0x100001
    - printf("%p\n", (unsigned int*)p + 0x1); 第三个 p r i n t f printf printf 语句，先将 p p p 强制类型转换成 u n s i g n e d unsigned unsigned i n t int int *类型， u n s i g n e d unsigned unsigned i n t int int 大小为 4 个字节，所以 +1 跳过 4 个字节，十六进制表示。答案：0x100004
      
      运行结果：
      
      三、题三
```
int main()
{int a[3][2] = { (0,1),(2,3),(4,5) };
	int* p;
	p = a[0];
	printf("%d\n", p[0]);
	return 0;
}
```
      - int a[3][2] = { (0,1),(2,3),(4,5) };先来看对数组的初始化。这里有个小坑点： { (0,1 ), (2,3 ), (4,5 ) } 大括号内是三个小括号，表示的是逗号表达式，并不是三个大括号，按行初始化。逗号表达式，从左到右一次执行，整个表达式的结果是最后一个表达式的结果。
        因此数组中存放的数据是：
        
        p = a[0]; a [ 0 ] 可以看做是二维数组中，第一行数组的数组名，数组名表示的是数组首元素的地址，即 p p p 中存放的是 1 的地址
        
        printf("%d\n", p[0]); p [ 0 ] 相当于*(p + 0) == *p，即打印 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]分别指向哪个元素。
        
        首先来看&a[4][2]，
        
        & a [ 4 ] [ 2 ] a[4][2] a[4][2] 等价于 & * ( * (a + 4)+ 2），& 和 * 相互抵消，即等价于 * (a + 4)+ 2。这里 a a a 是什么呢？ a a a 是第一行这个一维数组的地址，类型为 i n t ( ∗ ) [ 5 ] int(*)[5] int(∗)[5]。 a a a + 4，指向第五行。再对其进行解引用，得到的是第五行这个数组，即第五行的数组名，即第五行数组首元素的地址，对其 +2，指向第五行第三个元素。
        
        接着我们来看&p[4][2]，
        
        p p p 的类型为 i n t ( ∗ ) [ 4 ] int(* )[4] int(∗)[4] ，题目中将 a a a 的地址给 p p p ，其实会报警告，因为 a a a 是 i n t ( ∗ ) [ 5 ] int( * )[5] int(∗)[5] 类型，类型不匹配，但程序能运行。
        
        &p[4][2] 等价于* (p + 4)+ 2。首先，我们要理解 p p p + 1 跳过几个字节。因为 p p p 的类型为 i n t ( ∗ ) [ 4 ] int(* )[4] int(∗)[4] ，所以在 p p p 眼里，二维数组 a a a 是一个每行有 4 个元素的数组，+1 跳过的是 4 个整型，即 16 个字节。而 p p p + 4 则是过了 16 个整型，即 64 个字节
        
        * (p + 4) + 2：对 p p p 进行解引用，再 +2，这个过程与 * (a + 4)+ 2 相同，即指针移动了两个整型大小的字节，指向第三个元素。
        
        可以看到，&p[4][2]与&a[4][2]之间相差了 4 个元素，因为&p[4][2]是小地址，所以 &p[4][2] - &a[4][2] = -4
        
        printf("%p,%d\n", &p[4][2] - &a[4][2], &p[4][2] - &a[4][2]); &p[4][2] - &a[4][2]的结果是 - 4，因此以%d的形式打印没问题。那以%p形式打印呢？%p是打印地址，地址肯定是无符号类型。- 4 的补码是11111111 11111111 11111111 11111100，转为十六进制为 FF FF FF FC。
        
        运行结果:
        
        五、题五
        
        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\n", *(ptr1 - 1), *(ptr2 - 1)); return 0; }
        
        这道题的数组初始化没有坑啊，不用担心。
        
        int* ptr1 = (int*)(&aa + 1); & a a aa aa：& + 数组名，取出的是整个数组的地址，+1 跳过整个数组，再将其强制类型转换成 i n t int int* 类型。
        
        int* ptr2 = (int*)(*(aa + 1)); a a aa aa 是数组首元素的地址，即第一行的地址，+1 跳过第一行，指向第二行。对其进行解引用，得到的是第二行的数组名，即第二行首元素的地址。其实这里强制类型转换成 i n t int int *是多余的，第二行首元素的地址本来就是 i n t int int *类型。
        
        printf("%d %d", *(ptr1 - 1), *(ptr2 - 1)); 此时 * ( p t r 1 − 1 ) (ptr1 - 1) (ptr1−1) 与 * ( p t r 2 − 1 ) (ptr2 - 1) (ptr2−1) 都是 i n t int int *类型，- 1 后退 4 个字节，即一个整型元素。
        
        运行结果：
        
        六、题六
        
        int main() {char* a[] = { "work","at","alibaba" }; char** pa = a; pa++; printf("%s\n", *pa); return 0; }
        
        char* a[ ] = { "work","at","alibaba" }; 这是一个指针数组，数组中每个元素都放着指向对应字符串的首元素的地址。
        
        char** pa = a; 这里取出数组首元素的地址，因为数组首元素原本类型为指针类型，所以这里 p a pa pa 为二级指针。
        
        pa++; p a pa pa = p a pa pa + 1，指向数组第二个元素的地址。
        
        printf("%s\n", *pa); 对 p a pa pa 解引用，得到指向 “ a t at at” 的地址，打印 a t at at。
        
        运行结果：
        
        可能有些小伙伴对二级指针有点迷糊，这张图就一目了然啦（这里是 x86 环境下，x64 环境下指针变量大小 8 字节）
        
        这里我们可以把各个地址打印出来观察
        
        int main() {char* a[] = { "work","at","alibaba" }; printf("%p\n", &a[0]); printf("%p\n", &a[1]); printf("%p\n", &a[2]); printf("\n"); printf("%p\n", a[0]); printf("%p\n", a[1]); printf("%p\n", a[2]); return 0; }
        
        运行结果：
        
        七、题七
        
        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);
        
        前置++ 与解引用操作符 ∗ * ∗ 的优先级一致，根据结合性从右往左运算
        先是 c p p cpp cpp 自增，自增后指向 c p [ 1 ] cp[1] cp[1]
        第一次解引用，找到 c p [ 1 ] cp[1] cp[1]，第二次解引用找到 c [ 2 ] c[2] c[2]
        最终打印：POINT
        
        printf("%s\n", *-- * ++cpp + 3);
        
        首先 + 运算符优先级最小，因此 +3 最后才算
        其他四个操作符优先级一样，根据结合性从左到右计算
        先是 c p p cpp cpp 自增，自增后指向 c p [ 2 ] cp[2] cp[2]
        c p p cpp cpp 解引用，找到 c p [ 2 ] cp[2] cp[2]
        c p [ 2 ] cp[2] cp[2] 自减， c c c + 1 自减为 c c c ，原本指向 c [ 1 ] c[1] c[1]，自减后指向 c [ 0 ] c[0] c[0]
        c p [ 2 ] cp[2] cp[2] 解引用，找到 c [ 0 ] c[0] c[0]
        c [ 0 ] c[0] c[0] 指向的是 “ENTER” 字符串的首元素 'E’ ，+3 则指向 ‘E’
        答案：ER
        
        printf("%s\n", *cpp[-2] + 3);
        
        首先来看 c p p [ − 2 ] cpp[-2] cpp[−2]，它等价于 * ( c p p − 2 ) (cpp - 2) (cpp−2)， c p p cpp cpp - 2 后再解引用（注： c p p cpp cpp 本身值没变），找到 c p [ 0 ] cp[0] cp[0]
        接着，再解引用，找到 c [ 3 ] c[3] c[3]
        c [ 3 ] c[3] c[3] 指向 “FIRST” 字符串的首元素 'F’，+3 则指向 ‘S’
        答案：ST
        
        printf("%s\n", cpp[-1][-1] + 1);
        
        c p p [ − 1 ] [ − 1 ] cpp[-1][-1] cpp[−1][−1] 等价于 * ( * ( c p p cpp cpp - 1 ) - 1)，先来看里面的 *( c p p cpp cpp - 1)，将其解引用，找到 c p [ 1 ] cp[1] cp[1]
        接着，再看 * ( c p [ 1 ] − 1 ) (cp[1] - 1) (cp[1]−1)， c p [ 1 ] − 1 cp[1] - 1 cp[1]−1，原本指向 c [ 2 ] c[2] c[2]，- 1 后指向 c [ 1 ] c[1] c[1]。
        c [ 1 ] c[1] c[1] 指向 “NEW” 字符串的首元素 'N’，+1 则指向 ‘E’
        答案：EW

数组 类型

相关推荐

