@toc


前言

本篇文章的内容为指针进阶的相关练习题目,主要是进行指针的练习和巩固,继续上两篇指针相关的内容练习。
【C语言进阶】——指针(一) (字符指针,数组指针,指针数组)
【C语言进阶】——指针(二) (函数指针,回调函数,qsort排序)


一、指针和数组经典笔试题解析:

1、请写出下面程序执行的结果

#include<stdio.h>
int main()
{
    //一维数组
    int a[] = { 1,2,3,4 };
    printf("%d\n", sizeof(a));
    printf("%d\n", sizeof(a + 0));
    printf("%d\n", sizeof(*a));
    printf("%d\n", sizeof(a + 1));
    printf("%d\n", sizeof(a[1]));
    printf("%d\n", sizeof(&a));
    printf("%d\n", sizeof(*&a));
    printf("%d\n", sizeof(&a + 1));
    printf("%d\n", sizeof(&a[0]));
    printf("%d\n", sizeof(&a[0] + 1));
    return 0;
}

解析数组名表示首元素地址但有两个例外
1.sizeof(数组名)-- - 此时数组名表示整个数组。

2.& 数组名-- - 此时数组名表示整个数组。
注意:上面这两种例外的情况都需要 sizeof / &后面直接跟数组名,如果不是直接 + 数组名,则不是表示整数数组。
除了上面两个例外情况外,余下遇到的所有情况数组名均表示首元素地址

详解及结果展示:

#include<stdio.h>
int main()
{
    //一维数组
    int a[] = { 1,2,3,4 };
    printf("%d\n", sizeof(a));
    // 16 sizeof(数组名),数组名表示整个数组,大小为4*4=16个字节
    printf("%d\n", sizeof(a + 0));
    //4/8 此时数组名表示首元素地址,a+0首元素地址+0仍表示首元素地址,地址大小为4/8个字节
    printf("%d\n", sizeof(*a));
    // 4  此时数组名表示首元素地址,*a表示首元素,为int类型,大小为4个字节
    printf("%d\n", sizeof(a + 1));
    //4/8 此时数组名表示首元素地址,a+1 首元素地址+1表示第二个元素地址,地址大小为4/8个字节
    printf("%d\n", sizeof(a[1]));
    //4 此时数组名表示首元素地址 a[1]表示第二个元素,为int类型,大小为4个字节
    printf("%d\n", sizeof(&a));
    //4/8 &数组名表示取出数组的地址,地址大小为4/8个字节
    printf("%d\n", sizeof(*&a));
    //16 &a是取出数组地址,*&a是对数组地址解引用,得到是数组,sizeof(数组)计算数组大小--16
    printf("%d\n", sizeof(&a + 1));
    //4/8 &a是取出数组地址,&a+1表示跳过整个数组,指向整个数组后面的地址,地址大小为4/8个字节
    printf("%d\n", sizeof(&a[0]));
    //4/8 &a[0]表示取出第一个元素的地址,地址大小为4/8个字节
    printf("%d\n", sizeof(&a[0] + 1));
    //4/8 &a[0]表示取出第一个元素的地址,&a[0] + 1表示第二个元素的地址,地址大小为4/8个字节
    return 0;
}

image-20210817132550875


2、请写出下面程序执行的结果

#include<stdio.h>
int main()
{
    //字符数组
    char arr[] = { 'a ', 'b', 'c', 'd', 'e', 'f' };
    printf("%d \n", sizeof(arr));
    printf("%d\n", sizeof(arr + 0));
    printf("%d\n", sizeof(*arr));
    printf("%d\n", sizeof(arr[1]));
    printf("%d\n", sizeof(&arr));
    printf("%d\n", sizeof(&arr + 1));
    printf("%d \n", sizeof(&arr[0] + 1));
    return 0;
}

详解及结果展示:

#include<stdio.h>
int main()
{
    //字符数组
    char arr[] = { 'a ', 'b', 'c', 'd', 'e', 'f' };
    printf("%d \n", sizeof(arr));
    //6  计算的是数组大小,每个元素是一个字符,6*1=1
    printf("%d\n", sizeof(arr + 0));
    //4/8 arr+0还是表示首元素地址,地址大小是4/8个字节
    printf("%d\n", sizeof(*arr));
    //1 *arr表示首元素,类型是char,char大小是1个字节
    printf("%d\n", sizeof(arr[1]));
    //1 arr[1]表示第二个元素,类型是char,char大小是1个字节
    printf("%d\n", sizeof(&arr));
    //4/8 &arr表示取出数组的地址,地址大小是4/8个字节
    printf("%d\n", sizeof(&arr + 1));
    //4/8 &arr表示取出数组的地址,&arr+1表示跳过整个数组,到数组后面的地址,地址大小是4/8个字节 
    printf("%d \n", sizeof(&arr[0] + 1));
    //4/8 &arr[0]表示取出首元素的地址,&arr[0]+1表示取出第二个元素的地址,地址大小是4/8个字节
    return 0;
}

image-20210817133139500


3、请写出下面程序执行的结果

strlen函数是求字符串长度,需要找到 ' /0 '

#include<stdio.h>
#include<string.h>
int main()
{
    //字符数组
    char arr[] = { 'a ', 'b', 'c', 'd', 'e', 'f' };
    printf("%d\n", str1en(arr));
    printf("%d\n", strlen(arr + 0));
    printf("%d\n", str1en(*arr));
    printf("%d\n", strlen(arr[1]));
    printf("%d\n", str1en(&arr));
    printf("%d\n", str1en(&arr + 1));
    printf("%d\n", str1en(&arr[0] + 1));
    return 0;
}

详解及结果展示:

#include<stdio.h>
#include<string.h>
int main()
{
    //字符数组
    char arr[] = { 'a ', 'b', 'c', 'd', 'e', 'f' };
    printf("%d\n", strlen(arr));
    //随机值, arr表示首元素地址,数组中没有\0,所以用strlen计算长度的时候不知道会在哪里停止,所以是随机值
    printf("%d\n", strlen(arr + 0));
    //随机值, arr+0表示首元素地址,数组中没有\0,所以用strlen计算长度的时候不知道会在哪里停止,所以是随机值
    printf("%d\n", str1en(*arr));
    //错误写法 ,strlen后面需要传递一个地址,*arr表示首元素,首元素是字符'a',其ASCII码是97,strlen会将97当作地址来处理
    //此时会造成越界访问,运行时会报错
    printf("%d\n", strlen(arr[1]));
    //错误写法 ,strlen后面需要传递一个地址,arr[1]表示第二个元素,首元素是字符'b',其ASCII码是98,strlen会将97当作地址来处理
    //此时会造成越界访问,运行时会报错
    printf("%d\n", strlen(&arr));
    //随机值, &arr表示数组的地址,数组中没有\0,所以用strlen计算长度的时候不知道会在哪里停止,所以是随机值
    printf("%d\n", strlen(&arr + 1));
    //随机值, &arr+1表示跳过数组后的地址,后面不知道什么时候遇到'\0',所以是随机值
    printf("%d\n", strlen(&arr[0] + 1));
    //随机值, &arr[0] + 1表示第二个元素的地址,后面不知道什么时候遇到'\0',所以是随机值
    return 0;
}

image-20210817134953338


4、请写出下面程序执行的结果

#include<stdio.h>
int main()
{
    char arr[] = "abcdef";
    printf("%d\n", sizeof(arr));
    printf("%d\n", sizeof(arr + 0));
    printf("%d\n", sizeof(*arr));
    printf("%d\n", sizeof(arr[1]));
    printf("%d \n", sizeof(&arr));
    printf("%d\n", sizeof(&arr + 1));
    printf("%d\n", sizeof(&arr[0] + 1));

    return 0;
}

详解及结果展示:

#include<stdio.h>
int main()
{
    char arr[] = "abcdef";
    printf("%d\n", sizeof(arr));
    //7  用字符串来初始化字符串数组时,最后会自动添加字符串结束标志'\0'
    //数组arr中实际存放 abcdef+\0 7个元素 所以sizeof(arr)求数组的长度是 1*7=7个字节
    printf("%d\n", sizeof(arr + 0));
    //4/8   arr + 0表示首元素地址,地址的大小是4/8个字节
    printf("%d\n", sizeof(*arr));
    //1  *arr表示首元素,arr首元素是一个字符char类型'a',大小是1个字节
    printf("%d\n", sizeof(arr[1]));
    //1  arr[1]表示第二个元素,arr首元素是一个字符char类型'a',大小是1个字节
    printf("%d \n", sizeof(&arr));
    //4/8  &arr表示取出数组的地址,地址的大小是4/8个字节
    printf("%d\n", sizeof(&arr + 1));
    //4/8   &arr + 1表示跳过数组的地址,得到数组后面的地址,地址的大小是4/8个字节
    printf("%d\n", sizeof(&arr[0] + 1));
    //4/8   &arr[0]表示首元素地址,&arr[0] + 1表示第二个元素的地址,地址的大小是4/8个字节
    return 0;
}

image-20210817141219502


5、请写出下面程序执行的结果

#include<stdio.h>
#include<string.h>
int main()
{
    char arr[] = "abcdef";
    printf("%d\n", strlen(arr));
    printf("%d\n", strlen(arr + 0));
    printf("%d\n", strlen(*arr));
    printf("%d\n", str1en(arr[1]));
    printf("%d\n", strlen(&arr));
    printf("%d\n", strlen(&arr + 1));
    printf("%d\n", strlen(&arr[0] + 1));
    return 0;
}

详解及结果展示:

#include<stdio.h>
#include<string.h>
int main()
{
    char arr[] = "abcdef";
    printf("%d\n", strlen(arr));
    //6 数组arr中实际包含"abcdef \0",strlen在往后找\0的时候,经过6个char刚好找到\0
    //strlen在计算字符串长度的时候,'\0'不计算到长度中
    printf("%d\n", strlen(arr + 0));
    //6 arr + 0表示首元素地址,与'\0'差6个字符,所以strlen计算长度为6
    printf("%d\n", strlen(*arr)); 
    //错误写法 *arr表示首元素,为字符‘a’,ASCII码是97,strlen会将97当作地址来处理
    //此时会造成越界访问,运行时会报错
    printf("%d\n", str1en(arr[1])); 
    //错误写法 arr[1]表示第二个元素,为字符‘b’,ASCII码是98,strlen会将98当作地址来处理
    //此时会造成越界访问,运行时会报错
    printf("%d\n", strlen(&arr));
    //6 &arr取出数组的地址,strlen在接收地址的时候是char*,会将数组的地址当作char*来使用
    //往后寻找'\0',经过6个char刚好找到\0
    printf("%d\n", strlen(&arr + 1));
    //随机值 &arr + 1跳过数组得到数组后面的地址,什么时候会遇到'\0'不确定,所以是随机值
    printf("%d\n", strlen(&arr[0] + 1));
    //5  &arr[0] + 1表示第二个元素的地址,经过5个char遇到'\0',所以strlen计算长度为5
    return 0;
}

image-20210817141917615


6、请写出下面程序执行的结果

#include<stdio.h>
int main()
{
    char* p = "abcdef";
    printf("%d \n", sizeof(p));
    printf("%d\n", sizeof(p + 1));
    printf("%d\n", sizeof(*p));
    printf("%d\n", sizeof(p[0]));
    printf("%d\n", sizeof(&p));
    printf("%d\n", sizeof(&p + 1));
    printf("%d\n", sizeof(&p[0] + 1));
    return 0;
}

详解及结果展示:

#include<stdio.h>
int main()
{
    char* p = "abcdef";
    //指针变量p存放的不是常量字符串"abcdef"本身,而是存放其首元素的地址,
    //即字符串"abcdef"中字符'a'的地址
    printf("%d \n", sizeof(p));
    //4/8 p是一个指针,指针大小32位/64位平台为4/8
    printf("%d\n", sizeof(p + 1));
    //4/8 p+1是一个地址,字符'b'的地址,地址大小为4/8
    printf("%d\n", sizeof(*p));
    //1  *p表示字符'a',类型是char,大小为1个字节
    printf("%d\n", sizeof(p[0]));
    //1  p[0]常量字符串第一个元素,即'a',类型是char,大小为1个字节
    printf("%d\n", sizeof(&p));
    //4/8 &p表示取出p的地址,地址大小为4/8
    printf("%d\n", sizeof(&p + 1));
    //4/8 &p+1表示取出p后面的地址,地址大小为4/8
    printf("%d\n", sizeof(&p[0] + 1));
    //4/8 &p[0] + 1表示第二个元素的地址,即'b'的地址,地址大小为4/8
    return 0;
}

image-20210817142554263


7、请写出下面程序执行的结果

#include<stdio.h>
#include<string.h>
int main()
{
    char* p = "abcdef";
    printf("%d\n", strlen(p));
    printf("%d\n", strlen(p + 1));
    printf("%d \n", strlen(*p));
    printf("%d\n", strlen(p[0]));
    printf("%d\n", strlen(&p));
    printf("%d\n", strlen(&p + 1));
    printf("%d \n", strlen(&p[0] + 1));
    return 0;
}

详解及结果展示:

#include<stdio.h>
#include<string.h>
int main()
{
    char* p = "abcdef";
    //指针变量p存放的不是常量字符串"abcdef"本身,而是存放其首元素的地址,
    //即字符串"abcdef"中字符'a'的地址
    printf("%d\n", strlen(p));
    //6 p存储的是'a'的地址,strlen从a开始往后找6个字符,找到'\0'
    //所以strlen计算的字符串长度为6
    printf("%d\n", strlen(p + 1));
    //5 p + 1是'b'的地址,strlen从b开始往后找5个字符,找到'\0'
    printf("%d \n", strlen(*p));
    //错误写法 *p为字符‘a’,ASCII码是97,strlen会将97当作地址来处理
    //此时会造成越界访问,运行时会报错
    printf("%d\n", strlen(p[0]));
    //错误写法 p[0]为字符‘a’,ASCII码是97,strlen会将97当作地址来处理
    //此时会造成越界访问,运行时会报错
    printf("%d\n", strlen(&p));
    //随机值 取出p的地址,传给strlen,strlen在往后寻找'\0',不知道什么时候遇到'\0'
    printf("%d\n", strlen(&p + 1));
    //随机值 取出p后面的地址,传给strlen,strlen在往后寻找'\0',不知道什么时候遇到'\0'
    printf("%d \n", strlen(&p[0] + 1));
    //5 p[0]表示首元素,&p[0]表示首元素地址,&p[0] + 1表示第二个元素'b'的地址
    //strlen从'b'开始计算字符串长度
    return 0;
}

image-20210817151551647


8、请写出下面程序执行的结果

int main()
{
    //二维数组
    int a[3][4] = { 0 };
    printf("%d\n", sizeof(a));
    printf("%d\n", sizeof(a[0][0]));
    printf("%d \n", sizeof(a[0]));
    printf("%d\n", sizeof(a[0] + 1));
    printf("%d\n", sizeof(*(a[0] + 1)));
    printf("%d\n", sizeof(a + 1));
    printf("%d\n", sizeof(*(a + 1)));
    printf("%d\n", sizeof(&a[0] + 1));
    printf("%d\n", sizeof(*(&a[0] + 1)));
    printf("%d\n", sizeof(*a));
    printf("%d \n", sizeof(a[3]));
    return 0;
}

详解及结果展示:

知识储备:
二维数组的数组名表示首元素地址时,首元素指的是第一行数组,也就是说首元素是数组数组名表示的是第一行数组的地址

image-20210817153321244

#include<stdio.h>
int main()
{
    //二维数组
    int a[3][4] = { 0 };
    printf("%d\n", sizeof(a));
    //3*4*4=48
    printf("%d\n", sizeof(a[0][0]));
    //4
    printf("%d \n", sizeof(a[0]));
    //4*4=16  a[0]相当于第一行作为一维数组的数组名,
    //sizeof(arr[0])把数组名单独放在sizeof()内,计算的是第一行的大小
    printf("%d\n", sizeof(a[0] + 1));
    //4/8   a[0]+1, a[0]放到表达式中了,是第一行作为数组的数组名,此时表示首元素地址
    //a[0]+1表示第一行第二个元素的地址,地址的大小为4/8
    printf("%d\n", sizeof(*(a[0] + 1)));
    //4    a[0]+1表示第一行第二个元素的地址 *(a[0] + 1)表示第一行第二个元素,类型是int
    printf("%d\n", sizeof(a + 1));
    //4/8   a表示首元素地址,把二维数组看作一维数组,a即第一行数组的地址,a + 1表示第二行的地址,地址的大小为4/8
    printf("%d\n", sizeof(*(a + 1)));
    //4*4=16  a + 1表示第二行的地址,*(a + 1)表示第二行数组,数组有4个元素,均为int类型
    printf("%d\n", sizeof(&a[0] + 1));
    //4/8    a[0]放到表达式中了,是第一行作为数组的数组名,此时表示首元素地址
    //&a[0] + 1表示第二行数组的地址,地址的大小是4/8
    printf("%d\n", sizeof(*(&a[0] + 1)));
    //4*4=16   &a[0] + 1表示第二行数组的地址,*(&a[0] + 1)表示第二行数组,数组有4个元素,均为int类型
    printf("%d\n", sizeof(*a));
    //4*4=16   a表示二维数组首元素地址,即第一行数组的地址,*a表示第一行数组,大小为4*4
    printf("%d \n", sizeof(a[3]));
    //4*4=16   假设有第四行的数组,此时第四行数组的大小是4*4=16
    //sizeof操作符()内部不参与真实运算,所以实际上没有去越界访问
    return 0;
}

image-20210817161309392


总结:
数组名表示首元素地址,但有两个例外,除了上面两个例外情况外,余下遇到的所有情况数组名均表示首元素地址

1.sizeof(数组名)-- - 此时数组名表示整个数组

2.& 数组名-- - 此时数组名表示整个数组

3.除上面两个例外,数组名都是首元素地址


二、指针笔试题:

笔试题1:

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

画图展示内存空间:
image-20210817161754734

详解及结果展示:

#include<stdio.h>
int main()
{
    int a[5] = { 1,2,3,4,5 };
    int* ptr = (int*)(&a + 1);
    //&a表示取出数组a的地址,&a+1表示跳过该数组,指向数组后面的地址
    printf("%d,%d", *(a + 1), *(ptr - 1));
    //此时a表示首元素地址,a+1表示第二个元素地址,* (a + 1)表示第二个元素---2
    // ptr表示数组后面的地址,ptr - 1表示数组末尾的地址,* (ptr - 1)表示数组最后一个元素---5
    //程序的结果是什么?
    //2,5
    return 0;
}

image-20210817161951543


写代码三种境界
1.看代码是代码
2.看代码是内存
3.看代码还是代码


笔试题2:

#include<stdio.h>
//由于还没学习结构体,这里告知结构体的大小是20个字节
struct Test
{
    int Num;
    char* pcName;
    short sDate;
    char cha[2];
    short sBa[4];
}*p;                      

//假设p 的值为0x100000。如下表表达式的值分别为多少?
int main()
{
    printf("%p\n", p + 0x1);
    printf("%p\n", (unsigned long)p + 0x1);
    printf("%p\n", (unsigned int*)p + 0x1);
    return 0;
}

详解及结果展示:

这个题目考察的就是指针类型的意义,指针 + -的步长,指针 + 1到底是加几个字节。

#include<stdio.h>
//由于还没学习结构体,这里告知结构体的大小是20个字节
struct Test
{
    int Num;
    char* pcName;
    short sDate;
    char cha[2];
    short sBa[4];
}*p;
//假设p 的值为0x100000。如下表表达式的值分别为多少?
int main()
{
    p = (struct Test*)0x100000;
    printf("%p\n", p + 0x1);
    //0x1---十六进制的1,对应到十进制也是1
    //0x100014 此时p是结构体指针,结构体大小是20个字节,p+1其地址+20
    printf("%p\n", (unsigned long)p + 0x1);
    //0x100001,此时p被强制类型转换成 unsigned long 类型,p+1就是地址+1(整数+1)
    printf("%p\n", (unsigned int*)p + 0x1);
    //0x100004,p被强制类型转换成unsigned int*类型,p+1就是跳过一个int类型,地址+4
    return 0;
}

image-20210817162127301


笔试题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;
}

详解及结果展示:

image-20210818130709830

#include<stdio.h>
int main()
{
    int a[4] = { 1,2,3,4 };
    int* ptr1 = (int*)(&a + 1);
    //&a表示取出数组的地址,&a+1表示跳过数组,到数组后面的地址
    //(int*)(&a+1)将这个地址强制类型转换成int*,放到ptr1里面
    int* ptr2 = (int*)((int)a + 1);
    //a表示数组首元素地址,(int)a将这个地址强制类型转换成int类型
    //(int)a + 1,就是地址+1
    //(int*)((int)a + 1)将这个地址强制类型转换成int*,放到ptr2里面
    printf("%x,%x", ptr1[-1], *ptr2);
    //4 ptr[-1]==>*(ptr-1)得到数组最后一个元素,即4,%x八进制打印结果也是4
    //02 00 00 00 *ptr2得到的就是被强制类型转换为int类型的地址的值+1,地址的单位是字节
    //ptr2解引用就是访问 00 00 00 02 (小端字节序存储),打印的时候就是 02 00 00 00
    return 0;
}

image-20210817162258135


笔试题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;
}

详解及结果展示:

a[3] [2] = { (0,1),(2,3),(4,5) }

image-20210817162356203

#include<stdio.h>
int main()
{
    int a[3][2] = { (0,1),(2,3),(4,5) };
    //初始化{}内部的( )是逗号表示式,结果是最后一个表达式的结果
    //相当于{1,3,5}
    int* p;
    p = a[0];//a[0]是第一行数组名,没有&,没有单独放到sizeofn()内,表示首元素地址
    //将二维数组第一行第一个元素的地址赋值给p
    printf("%d", p[0]);//等价*(p+0)
    //1
    return 0;
}

image-20210817162417550


笔试题5:

下面代码打印的结果是什么?

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

详解及结果展示:
image-20210818133734387

image-20210818134710546

#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]);
    //指针-指针得到两者之间元素的个数
    //指针相当于无符号数所以用打印补码
    //&p[4][2] - &a[4][2]之间相差4个元素,且p<a,得到-4 用%p打印就是FFFFFFFC
    //用%d打印就是-4
    printf("%p,%d\n", &a[4][2] - &p[4][2], &a[4][2] - &p[4][2]);
    return 0;
}

image-20210817162727743


笔试题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;
}

详解及结果展示:
image-20210817163636514

#include<stdio.h>
int main()
{
    int aa[2][5] = { 1,2,3,4,5,6,7,8,9,10 };
    int* ptr1 = (int*)(&aa + 1);
    //&aa + 1 跳过整个数组,指向数组后面的地址
    int* ptr2 = (int*)(*(aa + 1));
    //*(aa + 1) 等价与aa[1],第二行首元素地址
    printf("%d,%d", *(ptr1 - 1), *(ptr2 - 1));
    //10,5
    return 0;
}

image-20210817163655299


笔试题7:

下面代码打印的结果是什么?

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

详解及结果展示:

image-20210817163817515

#include<stdio.h>
int main()
{
    //字符指针数组只存储每个字符串-首字符地址
    char* a[] = { "work","at","alibaba" };
    char** pa = a;
    pa++;
    //pa指向a[1]的地址,a[1]存放"at"常量字符串的首地址
    printf("%s\n", *pa);
    //*pa找到a[1],打印 at
    return 0;
}

image-20210817163841579


笔试题8:

下面代码打印的结果是什么?

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

详解及结果展示:( 画图很重要!!!!! )

image-20210817164018857

image-20210818144812617

#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);
    //"POINT"
    printf("%s\n", *-- * ++cpp + 3);//先看(*++cpp)解引用拿到C+1内容,然后(*--c+1),内容由(c+1)变成了(c)了,就由c的地址解引用指向"ENTER",最后+3移动3个字节,打印"ER"
    //"ER"
    printf("%s\n", *cpp[-2] + 3);
    //"ST"
    printf("%s\n", cpp[-1][-1] + 1);
    //"EW"
    return 0;
}

image-20210818144902942


image-20210817164103811