昆明网站建设公司_,移动网站构建,网站制作公司哪家好,重庆网站seo多少钱#x1f341;博客主页#xff1a;江池俊的博客 #x1f4ab;收录专栏#xff1a;C语言刷题专栏 #x1f4a1;代码仓库#xff1a;江池俊的代码仓库 #x1f3aa;我的社区#xff1a;GeekHub #x1f389;欢迎大家点赞#x1f44d;评论#x1f4dd;收藏⭐ 文章目录 前… 博客主页江池俊的博客 收录专栏C语言刷题专栏 代码仓库江池俊的代码仓库 我的社区GeekHub 欢迎大家点赞评论收藏⭐ 文章目录 前言指针和数组笔试题一维数组字符指针sizeof()的计算strlen的计算总结 二维数组 指针笔试题笔试题1笔试题2笔试题3笔试题4笔试题5笔试题6笔试题7笔试题8 小结 前言 当涉及到计算机编程的核心概念时指针和数组无疑是最重要和基础的话题之一。无论你是初学者还是有经验的开发者深入理解和掌握这两个概念都能让你的编程技能得到质的提升。在本篇博客中我们将带你进入指针和数组的精彩世界探索其在编程中的作用和应用。无论你是为了笔试准备还是为了提升自己的技能这里都将为你提供一个深入学习的机会。 在本篇文章中如有遇到不懂的知识点可以参考以下文章《掌握指针进阶探索字符指针、数组指针和指针数组的妙用》、《掌握指针进阶一篇带你玩转函数指针、函数指针数组及指向函数指针数组的指针》希望对你有所帮助 注意 本次讲解是在vs2022 x86的环境下进行的即电脑的32位环境所以默认为指针大小占4个字节 指针和数组笔试题
一维数组
//一维数组
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));以上语句输出的结果是什么结果如下 解析
int main()
{//一维数组int a[] { 1,2,3,4 };//数组中有4个元素每个元素的类型为int类型所以数组所占字节大小为4*416printf(%d\n, sizeof(a));//sizeof里面的a表示的是整个数组所以这里求的是整个数组的大小即4*416printf(%d\n, sizeof(a 0));//a0 其实是下标为0的元素的地址即数组第一个元素的地址是地址就是4/8字节这里是32位环境所以大小是4个字节printf(%d\n, sizeof(*a));//*a是数组首元素计算的是数组首元素的大小单位是字节a为int类型所以大小为4个字节printf(%d\n, sizeof(a 1));//a为首元素地址1表示下表为1的元素地址即第二个元素的地址地址大小为4个字节printf(%d\n, sizeof(a[1]));//a[1]表示第二个元素计算的是第二个元素的大小大小为4个字节printf(%d\n, sizeof(a));//a是整个数组的地址整个数组的地址也是地址地址的大小为4个字节//a--- 类型int(*)[4] 数组指针类型printf(%d\n, sizeof(*a));//a是数组的地址*a就是拿到了数组*a -- a,a就是数组名sizeof(*a)--sizeof(a)//计算的是整个数组的大小单位是字节即大小是4*4 16个字节printf(%d\n, sizeof(a 1));//a是整个数组的地址a1跳过整个数组指向数组后边的空间是一个地址大小是4个字节printf(%d\n, sizeof(a[0]));//a[0]是首元素的地址计算的是首元素地址的大小为4个字节printf(%d\n, sizeof(a[0] 1));//a[0]表示第一个元素的地址1就是第二个元素的地址地址的大小为4个字节return 0;
}
//sizeof 类型---- size_t ---- unsigned int这里我们需要知道 1. sizeof(数组名)数组名表示整个数组。计算的是整个数组的大小,单位是字节。 2. 数组名数组名表示整个数组。取出的是整个数组的地址,1跳过的是整个数组。 除此之外所有的数组名都是数组首元素的地址 字符指针
sizeof()的计算
//字符数组 --- sizeof()
char arr[] {a,b,c,d,e,f};
printf(%d\n, sizeof(arr));
printf(%d\n, sizeof(arr0));
printf(%d\n, sizeof(*arr));
printf(%d\n, sizeof(arr[1]));
printf(%d\n, sizeof(arr));
printf(%d\n, sizeof(arr1));
printf(%d\n, sizeof(arr[0]1));以上语句输出的结果是什么结果如下 解析
int main()
{char arr[] { a,b,c,d,e,f };printf(%d\n, sizeof(arr));//arr单独放在sizeof内部计算的是整个数组的大小单位是字节所以大小为 6*1 6个字节printf(%d\n, sizeof(arr 0));//arr表示首元素地址0表示下标为0的元素地址即数组首元素的地址大小为4个字节printf(%d\n, sizeof(*arr));//arr是数组的首元素的地址*arr表示对arr解引用得到字符a大小为1字节printf(%d\n, sizeof(arr[1]));//arr[1]是第二个元素因为数组元素为char类型所以大小为1字节printf(%d\n, sizeof(arr));//arr表示取出整个数组的地址数组的地址也是地址大小为4个字节printf(%d\n, sizeof(arr 1));//arr表示取出整个数组的地址1表示跳过整个数组指向数组后边空间即f后面的地址大小为4个字节printf(%d\n, sizeof(arr[0] 1));//arr[0] 1表示数组第二个元素的地址大小为4个字节return 0;
}注意 如果 char arr[] abcdef; 这里的arr数组有7个元素加上一个’\0’编译器会默认为arr数组末尾添加结束标志‘\0’所以计算数组大小时结果不再是6而是7。 当使用指针存放字符串又会怎样
char *p abcdef;
printf(%d\n, sizeof(p));
printf(%d\n, sizeof(p1));
printf(%d\n, sizeof(*p));
printf(%d\n, sizeof(p[0]));
printf(%d\n, sizeof(p));
printf(%d\n, sizeof(p1));
printf(%d\n, sizeof(p[0]1));以上语句输出的结果是什么结果如下 解析
int main()
{char* p abcdef;printf(%d\n, sizeof(p));//p是存放字符串abcdef的指针变量是指针所以大小为4个字节printf(%d\n, sizeof(p 1));//p表示首元素的地址1表示下表为1的元素的地址即b的地址大小为4个字节printf(%d\n, sizeof(*p));//p表示首元素的地址对p解引用*p就是字符asizeof(*p)计算的是字符的大小是1个字节printf(%d\n, sizeof(p[0]));//p[0]--*(p0) -- *p 表示第一个元素a大小是1个字节printf(%d\n, sizeof(p));//p是二级指针是指针大小为4个字节printf(%d\n, sizeof(p 1)); //p是二级指针1跳过的是p变量后即指针大小为4个字节的地址因为还是指针所以大小为4个字节printf(%d\n, sizeof(p[0] 1));//p[0]就是‘a’,p[0]就是a的地址1就是b的地址是地址大小为4个字节return 0;
}strlen的计算
//size_t strlen(const char* str)
//strlen返回类型为size_t ---- unsigned int
char arr[] { a,b,c,d,e,f };
printf(%d\n, strlen(arr));
printf(%d\n, strlen(arr 0));
//printf(%d\n, strlen(*arr));
//printf(%d\n, strlen(arr[1]));
printf(%d\n, strlen(arr));
printf(%d\n, strlen(arr 1));
printf(%d\n, strlen(arr[0] 1));输出结果如下 解析
int main()
{//size_t strlen(const char* str)//strlen返回类型为size_t ---- unsigned intchar arr[] { a,b,c,d,e,f };printf(%d\n, strlen(arr));//strlen统计字符串长度时直到遇到 \0才停止但是在初始化arr时我们没有加上\0,//即在arr数组中我们不知道\0的位置所以这里计算的结果是随机值printf(%d\n, strlen(arr 0));//这里计算的是从下标为0的元素位置开始计算字符串长度由于无法得知结束标志\0的位置所以结果同上为随机值//printf(%d\n, strlen(*arr)); --- //strlen需要接收的是一个地址strlen(a) - strlen(97),非法访问 - error//printf(%d\n, strlen(arr[1])); --- //b-98,和上面的代码类似是非法访问 - errorprintf(%d\n, strlen(arr));//arr虽然是整个数组的地址但是也是从数组起始位置开始的计算的结果同第一个一样还是随机值//arr类型 --- char(*)[6]数组指针类型printf(%d\n, strlen(arr 1));//arr是整个数组的地址arr1是跳过整个数组的地址即f后面的地址计算的是f后面的字符串长度//结果也是随即值但是这个随机值比第一个少6少的是字符串abcdefprintf(%d\n, strlen(arr[0] 1));//arr[0]表示的是第一个元素的地址 1表示第二个元素的地址是b的地址计算的是从b开始的字符串的长度//结果也是随机值但是这个随机值比第一个少1少的是字符areturn 0;
}char arr[] abcdef;
printf(%d\n, strlen(arr));
printf(%d\n, strlen(arr 0));
//printf(%d\n, strlen(*arr));
//printf(%d\n, strlen(arr[1]));
printf(%d\n, strlen(arr));
printf(%d\n, strlen(arr 1));
printf(%d\n, strlen(arr[0] 1));
return 0;输出结果如下 解析
int main()
{char arr[] abcdef;//数组是7个元素//[a b c d e f \0]printf(%d\n, strlen(arr));//arr是数组首元素的地址strlen从首元素的地址开始统计\0之前出现的字符个数结果是6printf(%d\n, strlen(arr 0));//arr 0是数组首元素的地址同第一个结果是6//printf(%d\n, strlen(*arr));//*arr是a,ASC II码值是97传给strlen是一个非法的地址造成非法访问//printf(%d\n, strlen(arr[1]));//b -- 98 ,同上printf(%d\n, strlen(arr));//arr虽然是整个数组的地址但是也是从数组起始位置开始的计算结果同第一个是6printf(%d\n, strlen(arr 1));//arr 1是跳过整个数组后的地址统计字符串的长度是随机值printf(%d\n, strlen(arr[0] 1));//arr[0]1是b的地址从第二个字符往后统计字符串的长度大小是5return 0;
}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));输出结果如下 解析
int main()
{char* p abcdef;printf(%d\n, strlen(p));//6- 求字符串长度printf(%d\n, strlen(p 1));//p 1是b的地址求字符串长度就是5//printf(%d\n, strlen(*p));//error*p是a//printf(%d\n, strlen(p[0]));//error -- 同上一个printf(%d\n, strlen(p));//p拿到的是p这个指针变量的起始地址从这里开始求字符串长度完全是随机值printf(%d\n, strlen(p 1));//p1是跳过p变量的地址从这里开始求字符串长度也是随机值printf(%d\n, strlen(p[0] 1));//p[0]表示a的地址 1是b的地址从b的地址向后数字符串的长度是5return 0;
}总结 sizeof 只关注占用内存空间的大小单位是字节不关心内存中存放的是什么 sizeof 是 操作符strlen是求字符串长度的统计的是\0之前出现的字符个数一定要找到 ‘\0’ 才算结束所以可能存在越界访问的 strlen是 库函数 二维数组
//二维数组
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(a1));
printf(%d\n,sizeof(*(a1)));
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]));以上语句输出的结果是什么结果如下 解析:
int main()
{//二维数组int a[3][4] { 0 };printf(%d\n, sizeof(a));//数组名单独放在sizeof内部a表示整个数组的地址计算的是整个数组的大小整个数组有3*412个元素//每个元素为int类型所以计算的大小为 3*4*4 12*4 48个字节printf(%d\n, sizeof(a[0][0]));//a[0][0]表示第一行第一列的元素即数组首元素大小为4个字节printf(%d\n, sizeof(a[0]));//a[0]是二维数组第一行的数组名数组名单独放在sizeof内部计算的就是数组(第一行)的大小为4*4 16个字节printf(%d\n, sizeof(a[0] 1));//a[0]作为第一行的数组名没有单独放在sizeof内部没有取地址表示的就是数组首元素的地址//那就是a[0][0]的地址a[0]1就是第一行第二个元素的地址是地址计算的大小就是4个字节printf(%d\n, sizeof(*(a[0] 1)));
//a[0] 1表示的是第一行第二个元素的地址对其解引用*(a[0] 1)就是是第一行第二个元素计算的是元素的大小为 4个字节printf(%d\n, sizeof(a 1));//a是二维数组的数组名数组名表示首元素的地址就是第一行的地址a1就是第二行的地址//第二行的地址也是地址是地址计算的大小就是4个字节 //a 类型 -- int (*)[4]数组指针类型//a1 类型: -- int(*)[4]数组指针类型printf(%d\n, sizeof(*(a 1)));//a1是第二行的地址对其解引用*(a1)表示的就是第二行*(a1) -- a[1]//因为第二行有4个元素每个元素为int类型所以计算大小为 4*4 16个字节printf(%d\n, sizeof(a[0] 1));//a[0]是第一行的地址a[0]1就是第二行的地址是地址大小就是4个字节printf(%d\n, sizeof(*(a[0] 1)));//*(a[0] 1) 是对第二行的地址解引用得到的就是第二行计算的就是第二行的大小为4*4 16个字节printf(%d\n, sizeof(*a));//a表示首元素的地址就是第一行的地址*a就是第一行计算的就是第一行的大小为 4*4 16个字节//*a -- *(a0) -- a[0]printf(%d\n, sizeof(a[3]));//结果是16个字节 -- int[4]//如果数组存在第四行a[3]就是第四行的数组名数组名单独放在sizeof内部计算的是第四行的大小,为 4*4 16个字节return 0;
}指针笔试题
笔试题1
int main()
{int a[5] { 1, 2, 3, 4, 5 };int *ptr (int *)(a 1);printf( %d,%d\n, *(a 1), *(ptr - 1));return 0;
}
//程序的结果是什么输出结果如下 解析
int a[5] { 1, 2, 3, 4, 5 }; 这行代码定义了一个包含5个整数的整型数组初始化为从1到5的连续整数。int* ptr (int*)(a 1);a表示的是整个数组的地址1跳过整个数组指向数组末尾后的地址此时是int()a[5]类型(int)表示的是将此地址强制转换成 int* 类型所以这行代码将一个指向整型的指针ptr指向数组a之后的内存位置也就是数组的末尾之后的位置。*(a 1)a表示数组首元素的地址1表示下标为1的元素的地址即第二个元素的地址对其解引用*(a1)表示第二个元素即2。*(ptr - 1)ptr表示的是5后面的地址-1就表示在该地址的条件下向前移动一个位置即指向5的地址对其解引用就得到元素5。 笔试题2
//由于还没学习结构体这里告知结构体的大小是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);printf(%p\n, (unsigned long)p 0x1);printf(%p\n, (unsigned int*)p 0x1);return 0;
}输出结果如下 解析
在给定的代码中有一个名为struct Test的结构体类型大小为20个字节。变量p是一个指向这种结构体类型的指针并被赋值为0x100000。
根据C语言中的指针算术规则指针在增加时会根据所指向类型的大小进行适当的偏移。 printf(%p\n, p 0x1); 因为p是结构体指针类型所以这里的表达式p 0x1会将指针p增加一个结构体的大小即20个字节20的16进制为0x14。故结果将是0x100014。 printf(%p\n, (unsigned long)p 0x1); 在这个表达式中将指针p先转换为unsigned long类型这时原来的结构体指针p就变成了unsigned long类型的数组加上0x1就是单纯的将0x100000加上0x1。所以结果将是0x100001。 printf(%p\n, (unsigned int*)p 0x1); 这个表达式中将指针p转换为unsigned int*类型然后增加0x1。因为unsigned int*大小是4个字节所以增加1个字节相当于增加0x4。故结果将是0x100004。
需要注意的是指针的算术运算会根据指针指向的类型来调整偏移量这取决于所使用的编译器和系统架构。此外将指针转换为不同类型可能会引起对齐和字节顺序等问题因此需要谨慎使用。 笔试题3
int main()
{int a[4] { 1, 2, 3, 4 };int *ptr1 (int *)(a 1);int *ptr2 (int *)((int)a 1);printf( %x,%x\n, ptr1[-1], *ptr2);return 0;
}输出结果如下 解析 int a[4] { 1, 2, 3, 4 }; 这行代码定义了一个包含4个整数的数组初始化为 1, 2, 3, 和 4。 int* ptr1 (int*)(a 1); 这里取数组a的地址表示整个数组的地址加1跳过了4个整型的大小然后将结果转换为int*类型的指针。这使得ptr1指向数组a之后的内存位置即4后面的地址。 int* ptr2 (int*)((int)a 1); 这里将数组a的值即数组的第一个元素的地址转换为int类型然后加1注意如果没有转换为int类型就是指针1实际上加了4个字节最后将结果转换为int*类型的指针。这使得ptr2指向数组a的第一个元素之后的内存位置。 printf(%x,%x\n, ptr1[-1], *ptr2); 这里使用指针ptr1访问了其前一个位置的值即数组a的最后一个元素并将它以十六进制格式打印出来。然后使用指针ptr2访问了其所指向位置的值即数组a的第二个元素并同样以十六进制格式打印出来。
由于ptr1指向数组a之后的位置而ptr2指向数组a的第一个元素之后的位置它们访问的内存位置是不同的。然而数组的元素在内存中是连续存储的因此最终输出的结果将受到内存布局的影响。 笔试题4
#include stdio.h
int main()
{int a[3][2] { (0, 1), (2, 3), (4, 5) };int *p;p a[0];printf( %d\n, p[0]);return 0;
}输出结果如下 解析
在这段代码中数组a是一个3x2的二维数组每个元素都是一个包含两个整数的小数组。 int a[3][2] { (0, 1), (2, 3), (4, 5) }; 这里使用逗号运算符初始化二维数组a的元素。逗号运算符的结果是它的最后一个表达式的值因此实际上是初始化了数组a的元素为 {1,3, 5}而0, 2, 4被忽略了。所以a的内容实际上是 {1, 3}, {5, 0}, {2, 4}。 int* p; 这里声明了一个指向整数的指针p。 p a[0]; 这里将指针p指向数组a的第一个元素即{1, 3}的首地址。 printf(%d\n, p[0]); 这里通过指针p访问了其第一个元素即数组a的第一个元素的第一个整数元素即1。然后将1以十进制格式打印出来。 笔试题5
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;
}输出结果如下 解析 int a[5][5]; 这行代码定义了一个5x5的二维整数数组。 int(*p)[4]; 这里定义了一个指向包含4个整数的数组的指针。 p a; 这里将指针p指向数组a的第一个子数组即a[0]二维数组的第一行地址。 printf(%p,%d\n, p[4][2] - a[4][2], p[4][2] - a[4][2]); 这行代码计算了两个地址之间的偏移量并打印出结果。
现在我们来计算偏移量 p[4][2] 表示指针p指向的数组的第5个子数组即第五行的元素然后取其中的第3个整数元素的地址。 a[4][2] 表示数组a的最后一行的第3个元素的地址。
因此表达式 p[4][2] - a[4][2] 会计算两个指针之间的偏移量这是一个指针运算计算的结果将是两个指针相差的数组元素个数。在这个特定的情况下由于p指向的数组每行有4个元素所以p[4][2]会在a[4][2]前面如图p[4][2]和a[4][2]之间有四个元素因此这个计算结果将是-4。 而%p是以16进制的形式打印其补码因为数据在内存中存储是以补码的形式存储的所以打印的时候也是打印补码-4的原、反、补码如下; 原 10000000 00000000 00000000 00000100 反 111111111 111111111 111111111 111111011 补 111111111 111111111 111111111 111111100 故其补码的16进制形式为 FFFFFFFC 笔试题6
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 aa[2][5] { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 }; 这行代码定义了一个2x5的二维整数数组并用初始化值填充它。 int* ptr1 (int*)(aa 1); 这里取数组aa的地址去出的是整个二维数组的地址加1跳过整个二维数组指向二维数组末尾后面的地址然后将结果转换为int*类型的指针。这将使得ptr1指向数组aa之后的内存位置即10后面的地址。 int* ptr2 (int*)(*(aa 1)); 这里aa表示的是二维数组首元素的地址即第一行的地址1跳过一行元素指向第二行的地址然后对其解引用得到第二行第一个元素的地址最后将结果转换为int*类型的指针。这将使得ptr2指向第二行的起始位置。 printf(%d,%d\n, *(ptr1 - 1), *(ptr2 - 1)); 这里使用指针算术访问了指针ptr1的前一个位置的值即数组aa的最后一个元素并将它打印出来。然后使用指针算术访问了指针ptr2的前一个位置的值即第二行的最后一个元素并将它打印出来。
注意ptr1 指向整个二维数组 aa 之后的位置而 ptr2 指向第二行的起始位置它们访问的内存位置是不同的。 笔试题7
#include stdio.h
int main()
{char *a[] {work,at,alibaba};char**pa a;pa;printf(%s\n, *pa);return 0;
}输出结果如下 解析 char *a[] {work,at,alibaba}; 这行代码定义了一个字符指针数组 a其中每个元素是一个指向字符串常量的指针。数组中有三个元素分别指向字符串 “work”、“at” 和 “alibaba”。 char**pa a; 这里定义了一个指向字符指针的指针 pa将其指向数组 a 的第一个元素即指向字符串 “work” 的指针。 pa; 这里将指针 pa 增加了一次使其指向数组 a 的下一个元素即指向字符串 “at” 的指针。 printf(%s\n, *pa); 这里通过指针 pa 访问了其所指向的字符串这里*pa表示的是字符串at的地址然后使用 %s 格式化输出该字符串。 笔试题8
int main()
{char *c[] {ENTER,NEW,POINT,FIRST};char**cp[] {c3,c2,c1,c};char***cpp cp;printf(%s\n, **cpp);printf(%s\n, *--*cpp3);printf(%s\n, *cpp[-2]3);printf(%s\n, cpp[-1][-1]1);return 0;
}输出结果如下 解析
这段代码涉及指针和指针数组的操作有点复杂让我们逐行解释 char* c[] { ENTER,NEW,POINT,FIRST }; 这行代码定义了一个字符指针数组 c其中每个元素是一个指向字符串常量的指针。数组中有四个元素分别指向字符串 “ENTER”、“NEW”、“POINT” 和 “FIRST”。 char** cp[] { c 3,c 2,c 1,c }; 这里定义了一个指向字符指针的指针数组 cp其中每个元素是一个指向数组 c 中的某个元素的指针。c 3 表示指向 “FIRST” 的指针c 2 表示指向 “POINT” 的指针以此类推。 char*** cpp cp; 这里定义了一个指向指针数组 cp 的指针 cpp。 printf(%s\n, **cpp); 这里首先将指针 cpp 增加了一次然后通过 ** 解引用两次得到 “POINT” 的字符串然后输出。 printf(%s\n, *-- * cpp 3); 这里先将指针 cpp 增加一次然后将其解引用得到指向 “NEW” 的指针。接着*-- * cpp 操作会将 *cpp 减少一次然后将其解引用得到字符串ENTER 的地址。最终 3 操作将 “ENTER” 的字符串地址向后偏移3得到字符串 “ER”然后输出。 printf(%s\n, *cpp[-2] 3); 这里使用指针数组的索引操作首先cpp[-2] 得到指向字符串 “FIRST” 的指针然后对其解引用得到字符串FIRST的地址最终 3 将 “FIRST” 的字符串地址向后偏移3得到字符串 “ST”然后输出。 printf(%s\n, cpp[-1][-1] 1); 这里 cpp[-1] 得到指向 “POINT” 的指针然后 cpp[-1][-1] 得到 “NEW” 的字符串指针地址然后 1 将字符串地址向后偏移1得到字符串 “EW”然后输出。
小结 理解和掌握指针和数组的概念是编程中的关键。通过练习和实践你将能够更好地处理与指针和数组相关的问题。遇到困难并不是失败而是在通向成功的道路上的一部分。每次犯错你都在学习如何做得更好。我们一起加油✨☄ 今天的分享就到这里了 如果觉得博主的文章还不错的话 请三连支持一下博主哦
