C语言指针相关知识（第五篇章）（非常详细版）

最新推荐文章于 2024-06-14 10:22:04 发布
最新推荐文章于 2024-06-14 10:22:04 发布
阅读量931 收藏 19
点赞数 37
文章标签： c语言 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_74949249/article/details/138499803
版权

提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档

文章目录

前言

`本文主要介绍strlen与sizeof的区别，利于strlen与sizeof来对比一维数组，字符数组以及二维数组，加深理解数组之间的区别与联系，最后讲解几个复杂指针的运算

提示：以下是本篇文章正文内容，下面案例可供参考

一、sizeof和strlen对比

  • sizeof是一种操作符，它所计算的是所占内存空间的大小，单位是字节，如果操作数是类型的话计算的是使用类型的创建的变量所占内存空间的大小。在这里注意：sizeof只关注占用内存空间的大小，不在乎内存中存放什么数据，而且sizeof参数中的表达式不实际运算。
#include<stdio.h>
int main()
{
	int a = 10;
	printf("%d\n", sizeof(a));
	printf("%d\n", sizeof a);
	printf("%d\n", sizeof(int));
	return 0;
}

在这里插入图片描述
运行结果都是4，不管内存中存放的是什么数据，只关注占用的内存空间大小，int类型也好，a变量也好，它们都占有4个字节大小。

  • strlen是C语言库函数，它的功能就是求字符串长度，函数原型为： size_t strlen ( const char * str );它统计的是从参数str中这个地址开始向后，到\0之前的字符个数，如果没有找到\0，strlen函数会一直向后统计，直到找到\0为止，所以可能会存在越界的行为。
#include<stdio.h>
int main()
{
	char arr1[3] = { 'a', 'b', 'c' };
	char arr2[] = "abc";
	printf("%d\n", strlen(arr1));
	printf("%d\n", strlen(arr2));
}

在这里插入图片描述
理论上来说，打印出来的数应该一样，但由运行结果来看，arr1的字符数量明显不对，这是因为arr1没有设置\0，而arr2用字符串赋值后面自带一个\0，所以在统计arr1的字符数量时候，存在了越界问题

  • 两者对比：
    在这里插入图片描述

二、数组之间的比较（依据strlen和sizeof来呈现）

下面代码我们是在X86环境下运行

（一）、一维整型数组

  • 分析以下代码：
//在X86环境下运行
#include<stdio.h>
int main()
{
	int a[] = { 1,2,3,4 };
	printf("%zd\n", sizeof(a));//第一条：16，a表示的是整个数组，整个数组的大小，单位是字节
	printf("%zd\n", sizeof(a + 0));//第二条：4，a代表首元素地址
	printf("%zd\n", sizeof(*a));//第三条：4，a代表首元素地址，解引用后为第一个整型大小
	printf("%zd\n", sizeof(a + 1));//第四条：4，a代表首元素地址，a+1代表第二个元素地址
	printf("%zd\n", sizeof(a[1]));//第五条：4，为数组第二个元素整型大小
	printf("%zd\n", sizeof(&a));//第六条：4//为整个数组的地址，只要是地址就是4
	printf("%zd\n", sizeof(*&a));//第七条：16
	//解释：
	//1.&和*相互抵消sizeof(*&a)==sizeof(a)
	//2.&a-是数组地址，类型是int(*)[4]数组指针类型，*&a访问的就是这个数组
	printf("%zd\n", sizeof(&a + 1));//第八条：4，第二个数组的地址，只要是地址就是4
	printf("%zd\n", sizeof(&a[0]));//第九条：4，第一个元素地址，只要是地址就是4
	printf("%zd\n", sizeof(&a[0] + 1));//第十条：4，第二个元素地址，只要是地址就是4
}

在这里插入图片描述
分析：

  • 第一条代码：运行结果为16.这里的数组名因为sizeof的参数只有a自己，所以代表的是整个数组，一个数组4个元素，一个整型元素4个字节（在X86环境下）所以，最终结果为16
  • 第二条代码：运行结果为4.这里的数组名代表的是首元素地址，因为sizof中参数不只有a自己还有+0，在X86环境下，只要是地址，它的大小就是4个字节
  • 第三条代码：运行结果为4.a代表的是首元素地址，即整型元素1的地址，然后进行解引用，得出的是整型1，它所占空间为4个字节。
  • 第四条代码：运行结果为4.a代表的是首元素地址，加1后代表的是第二个元素的地址，只要是地址，其所占用的空间就是4个字节。
  • 第五条代码：运行结果为4.a[1]代表的是数组第二个元素2，它是int型元素，是4个字节
  • 第六条代码：运行结果为4.&a代表整个数组的地址，只要是地址，在此环境下就是4个字节。
  • 第七条代码：运行结果为16.两种解释，第一种：&和 * 相互抵消sizeof( * %a)==sizeof(a)，与第一条运行结果相同。第二种解释：&a是代表的是整个数组地址，类型是int( * )[4]数组指针类型，* &a访问的就是这个数组，而这个数组就是16个字节。
  • 第八条代码：运行结果为4。&a+1代表的是第二个数组的地址，只要是地址就是4个字节。
  • 第九条代码：运行结果为4.&a[0]代表的是第一个元素的地址，只要是地址那么大小就是4个字节。
  • 第十条代码：运行结果为4.&a[0]+1代表的是第二个元素的地址，只要是地址那么大小就是4个字节。

以上的每一条代码深刻领会后，就会感受到一维数组的细节内容。像对一维数组数组名的理解，一维数组中解引用的理解，一维数组的地址的理解，一维数组中的运算操作等等。

（二）、字符数组

  • 分析下面代码1：
#include<stdio.h>
int main()
{
	char arr[] = { 'a','b','c','d','e','f' };
	printf("%zd\n", strlen(arr));//第一条：随机值，arr代表数组首元素地址
	printf("%zd\n", strlen(arr + 0));//第二条：随机值，arr代表数组首元素地址
	//printf("%zd\n", strlen(*arr));//第三条：代码出错无法运行，这里先注释掉后面分析
	//printf("%zd\n", strlen(arr[1]));第四条：代码出错无法运行，这里先注释掉后面再分析
	printf("%zd\n", strlen(&arr));//第五条：随机值
	printf("%zd\n", strlen(&arr + 1));//第六条：随机值
	printf("%zd\n", strlen(&arr[0] + 1));//第七条：随机值
}

在这里插入图片描述
分析：

  • 第一条代码：运行结果为19，arr代表的是数组首元素的地址，从此地址出发，直到找到\0为止，但是我们一开始没有在数组中赋值\0，所以最终得出的是随机值。

  • 第二条代码：运行结果为19.arr+0也代表首元素地址，分析同第一条代码

  • 第三条代码：运行结果为程序错误，我们这里给注释掉。arr维首元素地址，对其进行解引用，*arr代表的就是‘a’字符，它的ASCII值为97，将其传给strlen，strlen会认为97就是地址，然后去访问内存，会发生访问冲突

  • 第四条代码：运行结果为程序错误，arr[1],代表的是’b’字符，它的ASCII值为98，将其传给strlen，strlen会认为98就是地址，然后去访问内存，会发生访问冲突.

  • 第五条代码：运行结果为19。&arr，这里arr代表的是整个数组，参数是整个数组的地址，从此地址出发，直到找到\0为止，但是我们一开始没有在数组中赋值\0，所以最终得出的是随机值。

  • 第六条代码：运行结果为13.&arr+1代表的是第二个数组的地址。从此出发，后面有没有\0仍然未知，是随机值，但会比第5条代码少5，因为他们之间一定差了一个数组的元素个数

  • 第七条代码：运行结果为18.&arr[0]+1，代表的是第二个元素的地址，从此地址开始访问，因为后面没有设置\0，所以访问的仍然是随机值，但比第一条代码会少1.

  • 分析下面代码2：

#include<stdio.h>
int main()
{
char arr[] = "abcdef";
printf("%zd\n", sizeof(arr));//第一条：7，arr数组名表示的是整个数组计算的是整个数组的大小
printf("%zd\n", sizeof(arr+0));//第二条：4，arr+0代表的是数组首元素的地址，既然是地址，大小就是4个字节
printf("%zd\n", sizeof(*arr));//第三条：1，*arr代表的是数组首元素--a大小为一个字节
printf("%zd\n", sizeof(arr[1]));//第四条：1，arr[1]代表的是数组中第二个元素-b的大小
printf("%zd\n", sizeof(&arr));//第五条：4//&arr代表的是数组的地址
printf("%zd\n", sizeof(&arr+1));//第六条:4//&arr代表的是数组的地址，+1后代表跳过整个数组后，这指向了数组后面的那个位置，但是&arr+1仍然是地址，只要是地址，就是4个字节
printf("%zd\n", sizeof(&arr[0]+1));//第七条：4，代表的是数组第二个元素的地址，只要是地址，就是4个字节
printf("%zd\n", strlen(arr));//第八条：6,数组名代表第一个元素地址
printf("%zd\n", strlen(arr+0));//第九条：6,数组名+0代表第一个元素地址
//	printf("%zd\n", strlen(*arr));//第十条：字符a-97，97作为地址传给了strlen，不能使用这个空间，注释掉
//	printf("%zd\n", strlen(arr[1]));//第十一条：字符b-98，98作为地址传给了strlen,不能访问这个空间，注释掉
printf("%zd\n", strlen(&arr));//第十二条：6，&arr是数组的地址，数组的地址和数组首元素的地址是指向同一个位置的
printf("%zd\n", strlen(&arr+1));//第十三条：随机值
printf("%zd\n", strlen(&arr[0]+1));//第十四条：5，从数组第二个位置开始访问
}

在这里插入图片描述
分析：

  • 第一条代码：运行结果为7.这里arr代表的是整个数组，sizeof（arr）计算的是整个数组的大小，因为一开始赋值的时候为字符串类型，所以末尾自动加了个\0。故而应该是7个字节大小。

  • 第二条代码：运行结果为4.这里arr代表数组首元素的地址+0也代表首元素的地址，只要是地址，在X86环境下，大小就是4个字节

  • 第三条代码：运行结果为1.这里arr代表的是数组首元素的地址，对其进行解引用，我们得到的是字符’a’.一个字符大小是一个字节

  • 第四条代码：运行结果为1。arr[1]代表的是数组第二个元素-‘b’，它是字符，其大小就是一个字节

  • 第五条代码：运行结果为4.&arr代表的是整个数组的地址，只要是地址，在x86环境下，大小就是4个字节。

  • 第六条代码：运行结果为4.%arr+1代表的是下一个数组的地址，只要是地址，在X86的环境下，大小就是4个字节

  • 第七条代码：运行结果为4.&arr[0]+1，代表的是第二个元素的地址，只要是地址，在X86环境下，大小就是4个字节。

  • 第八条代码：运行结果为6.arr代表的是数组首元素的地址，arr数组末尾有\0，从此地址出发，到\0之间共有6个元素，故而显示的结果就是6

  • 第九条代码：运行结果为6.arr+0代表的也是首元素的地址，分析结果同第一条代码。

  • 第十条代码：运行结果为程序错误。arr代表的是数组首元素的地址，对其进行解引用，指的是’a’其ASCII码值为97，将其传给strlen，strlen会认为97就是地址，然后去访问内存，会发生访问冲突

  • 第十一条代码：运行结果为程序错误。arr[1]代表的是字符’b’其ASCII码值为98，将其传给strlen，strlen会认为98就是地址，然后去访问内存，会发生访问冲突

  • 第十二条代码：运行结果为6.&arr是整个数组的地址，而整个数组的地址和首元素地址指向的是同一个位置，故而分析同第一条代码。

  • 第十三条代码：运行结果为随机值。&arr+1代表的是下一个数组的地址，而下一个数组我们没有赋值或者定义\0，故而显示的是随机值。

  • 第十四条代码：运行结果为5.&arr[0]+1代表的是第二个元素’b’的地址，从此地址到\0之间的元素有5个，故而最后显示的结果是5。

  • 分析下面代码3：
    字符串指针：可以理解成不能改变的字符数组

#include<stdio.h>
int main()
{
char* p = "abcdef";//可以理解成不能被改变的字符数组
printf("%zd\n", sizeof(p));//第一条：4，p是指针变量。计算的是指针变量p的大小，为4个字节
printf("%zd\n", sizeof(p+1));//第二条：4，p+1代表的是b元素的地址 为4个字节
printf("%zd\n", sizeof(*p));//第三条：1，代表a元素的大小
printf("%zd\n", sizeof(p[0]));//第四条：p[0]->*(p+0),代表a元素的大小1
printf("%zd\n", sizeof(&p));//第五条：4，p指针的地址，只要是地址就是4个字节
printf("%zd\n", sizeof(&p+1));//第六条：4，&p是p的地址，&p+1是跳过p变量，指向了p的后边，只要是地址就是4个字节
printf("%zd\n", sizeof(&p[0]+1));//第七条：4，代表b的地址，只要是地址就是4个字节
printf("%zd\n", strlen(p));//第八条：6,
printf("%zd\n", strlen(p+1));//第九条：5
//printf("%zd\n", strlen(*p));//第十条：程序崩坏，注释掉，后面分析
//printf("%zd\n", strlen(p[0]));//第十一条：程序崩坏，注释掉，后面分析
printf("%zd\n", strlen(&p));//第十二条：随机值
printf("%zd\n", strlen(&p+1));//第十三条：随机值
printf("%zd\n", strlen(&p[0]+1));//第十四条：5
}

在这里插入图片描述
分析：

  • 第一条代码：运行结果为4.p是指针变量，同时也代表的是字符’a’的地址，在X86环境下指针变量的大小为4字节.
  • 第二条代码：运行结果为4，p+1代表的是‘b’字符的地址，在X86环境下，其大小为4个字节
  • 第三条代码：运行结果为1.*p代表的是’a’字符，其大小为一个字节。
  • 第四条代码：运行结果为1.p[0]等价于* (p+0)指的是’a’字符，其大小为1个字节
  • 第五条代码：运行结果为4.&p代表的是p指针变量的地址，只要是地址，在X86环境下，其大小就是4个字节
  • 第六条代码：运行结果为4.&p代表的是p的地址，&p+1是跳过p变量，指向了p的后边，也代表地址，只要是地址，在X86环境下就是4个字节。
  • 第七条代码：运行结果为4.&p[0]+1代表的是’b’字符的地址，只要地址，在X86环境下就是4个字节
  • 第八条代码：运行结果为6.p代表的是’a’的地址，将其传给strlen函数，就是从此地址出发，统计到\0之前的元素个数，字符串末尾会自动加一个\0，故而结果为6.
  • 第九条代码：运行结果为5.p+1代表的是’b’字符的地址，将其传给strlen函数，就是从此地址出发，统计到\0之前的元素个数，故而会比第八条代码少1，结果为5.
  • 第十条代码：运行结果为程序错误。*p代表的是字符’a’，其ASCII码值为97，将其传给strlen，strlen会认为97就是地址，然后去访问内存，会发生访问冲突符。
  • 第十一条代码：运行结果为程序错误。p[0]代表的也是字符’a’，分析同第十条代码
  • 第十二条代码：运行结果为3.&p代表p变量的地址，，从此地址出发，因为后边我们没有一开始定义\0，所以最后统计的是随机值。
  • 第十三条代码：运行结果为随机值。&p+1代表的是跳过p变量，指向了p的后边，从此地址出发，因为后边我们没有一开始定义\0，所以最后统计的是随机值。
  • 第十四条代码：运行结果为5.&p[0]+1，代表的是’b’字符的地址，从此地址出发，到\0共有5个元素，故而结果为5.

以上的每一条代码深刻领会后，就会感受到字符数组的细节内容。像对字符数组数组名的理解，字符数组中解引用的理解，字符数组的地址的理解，字符数组中的运算操作，字符指针变量与字符数组关系等等。

（三）、二维数组

  • 分析以下代码：
#include<stdio.h>
int main()
{
int a[3][4] = { 0 };
printf("%zd\n", sizeof(a));//第一条：48，a作为二维数组数组名，单独放在sizeof中，说明这里a代表整个数组，计算的是整个数组的大小，单位是字节
printf("%zd\n", sizeof(a[0][0]));//第二条：4
printf("%zd\n", sizeof(a[0]));//第三条：16
printf("%zd\n", sizeof(a[0]+1));//第四条：4
printf("%zd\n", sizeof(*(a[0]+1)));//第五条：4,代表第一行第二个元素，大小是4个字节
//************
printf("%zd\n", sizeof(a+1));//第六条：4，代表第二行第一个元素的地址。a是二维数组数组名，并没有单独放在sizeof中，a代表的是首元素地址即第一行的地址，a+1代表第二行的地址，是地址大小就是4个字节
//************
printf("%zd\n", sizeof(*(a + 1)));//第七条：16
//1.*（a+1）--a[1]-是第二行的数组名，单独放到sizeof中，指的是整个数组的大小
//2.第一行地址＋1，即第二行的地址，为数组指针类型，对其进行解引用，访问的是整个第二行数组，大小是16个字节
printf("%zd\n", sizeof(&a[0]+1));//第八条：4，代表的是第二行的地址
//a[0]表示的是第一行的数组名，&数组名代表的是第一行的地址，&a[0]+1就是第二行的地址，是地址就是4个字节
printf("%zd\n", sizeof(*(&a[0] + 1)));//第九条：16；第二行地址解引用代表第二行整个数组
printf("%zd\n", sizeof(*a));//第十条：16.a代表的是第一行的地址，对第一行进行解引用代表的是第一行整个数组的大小，大小为16个字节
printf("%zd\n", sizeof(a[3]));//16第十一条：
//sizeof 内部的表达式是不会真实计算的，所以谈不上越界的问题
//a[3]-第四行的数组名，sizeof直接＋数组名，代表访问整个数组（即第四行）大小为16个字节
}

在这里插入图片描述
分析：

  • 第一条代码：运行结果为48.a作为二维数组的数组名，单独放在sizeof中代表了整个二维数组，共有12个元素，一个整型元素为4个字节。所以共占48个字节大小。
  • 第二条代码：运行结果为4.a[0][0]代表的是第一行第一列元素，其为整型类型，故而大小为4个字节。
  • 第三条代码：运行结果为16.a[0],是第一行的数组名，单独放在sizeof中，所以a[0]代表的是二维数组中第一行的一维数组，共有4个整型元素，故而占16个字节
  • 第四条代码：运行结果为4.a[0]是第一行的数组名，在这里它代表的是第一行首元素的地址，然后+1代表第一行第二个元素的地址，只要是地址，在X86环境下，大小为4个字节
  • 第五条代码：运行结果为4.a[0]+1代表的是第一行第二个元素的地址，然后对其进行解引用，得到的是整型0元素，大小为4个字节。
  • 第六条代码：运行结果为4.a是指二维数组数组名，在这里代表的是第一行一维数组的地址，+1后，代表的是第二行一维数组的地址，只要是地址，在X86环境下就是4个字节。
  • 第七条代码：运行结果为16.有两种解释：第一种，（a+1）代表的是第二行一维数组的地址，然后对其进行解引用，代表的是整个第二行一维数组，共有4个整型元素，故而占16个字节；第二种，*(a+1)等价于a[1]是第二行的数组名，单独放在sizeof中代表的是整个第二行一维数组，共有4个整型元素，故而占16个字节。
  • 第八条代码：运行结果为4.&a[0]代表的是第一行一维数组的地址，加一后，代表的是第二行一维数组的地址，只要是地址，在X86环境下，就是4个字节。
  • 第九条代码：运行结果为16.&a[0]+1代表第二行一维数组的地址，对其进行解引用后，代表的是整个整个第一行，共有4个整型元素，故而占16个字节。
  • 第十条代码：运行结果为16.a是二维数组的数组名，在这里代表的是第一行的地址，对第一行进行解引用代表的是第一行整个数组的大小，大小为16个字节
  • 第十一条代码：运行结果为16.sizeof内部是不会真实计算的，所以谈不上越界问题。a[3]-第四行的数组名，sizeof直接＋数组名，代表访问整个数组（即第四行）大小为16个字节

以上的每一条代码深刻领会后，就会感受到二维数组的细节内容。像对二维数组数组名的理解，将二维数组拆分成几个一维数组，它是几个一维数组的数组，二维数组地址的分析，解引用分析，运算等等。

三、复杂指针运算讲解

  • 代码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;
 }

运行结果：
在这里插入图片描述
分析：&a+1代表的是指向下一个数组的地址。将其强制转换成int后，赋值给ptr指针，ptr就是简单的整型指针，-1后代表整型元素5的地址，进行解引用后，代表整型元素5.（a+1）等价于a[1]，即2整型元素

  • 代码2：
//在X86环境下
//结构体的大小为20个字节
#include<stdio.h>
struct Test
{
 int Num;
 char *pcName;
 short sDate;
 char cha[2];
 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打印的是地址。我们应该清楚，指针+1是跟类型有关系，而整数+1，就是之间+1.第一条打印代码为指针+1（16进制）,struct Test*变量为20个字节，即加20个字节，因为是16进制，所以最终呈现的是00100014；第二条打印代码，为整数加1，直接加1即可，最终呈现为00100001。第三条打印代码仍然为指针+1，unsigned int类型变量是4个字节，所以最终呈现00100004

  • 代码3：
#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;
 }

运行结果：
在这里插入图片描述
分析:注意在给二维数组赋值的时候用的是小括号，即为逗号表达式形式，等价于int a[3][2]={1,3,5};即为以下形式
在这里插入图片描述
a[0]是第一行一维数组的数组名，代表第一行首元素的地址，将它赋值给p整型指针变量，p[0]等价于*（p+0）访问的是第一行的首元素1，故而输出为一。

  • 代码4：
//在X86的环境下，程序的输出结果
#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;
 }

运行结果为：
在这里插入图片描述
分析：p是数组指针类型，int(*)[4],而a也可以表示成数组指针的形式，它的类型就是int( * )[5],但是将a赋值为p，所以最终以p的类型为主，一开始a的地址与p的地址指向统一个位置，但是它俩类型不同，所以+1后跳过的元素也不同，p+1跳过4个元素，而a+1跳过5个元素.所以最终结果指向为:
在这里插入图片描述
%d是有符号整数，结果就是-4.
%p是打印的地址，为无符号整数，最终是以补码形式存在
-4的补码为：11111111111111111111111111111100，它所对应的无符号整数就是FF FF FF FC

  • 代码5：
#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;
 }

运行结果为：
在这里插入图片描述
分析：
在这里插入图片描述
&aa代表整个二维数组的地址，＋1后指向下一个二维数组，如图所示，然后强制转换成int型，-1后指向10整型元素，对其解引用后，打印出10；aa+1代表的是第二行一维数组的地址，对其解引用后代表整个第二行数组名，指的是第二行一维数组首元素的地址，然后强制类型转换成int型，-1后指向5元素地址，最后解引用后，指向元素5.

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

运行结果为：
在这里插入图片描述

分析：
在这里插入图片描述
a是二维数组数组名，代表的是二维数组首元素地址（即第一行一维数组的地址），这里用二级指针pa来接受，p++后，指向的二维数组第二行的地址（即第二行一维数组的地址），打印后即第二行的内容，即at.

  • 代码7：
#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;
 }

运行结果：
在这里插入图片描述
分析：
在这里插入图片描述
c 为指针数组类型，cp亦是指针数组类型，char为三级指针，代表的是cp首元素的地址，他们之间的对应关系如图。
注意++，–运算会改变cpp的值，影响后面计算
第一条打印代码分析：**++cpp，cpp+1是c+2的地址，进行解引用后代表c+2，在对c+2进行解引用后代表P的地址，然后进行打印后结果为POINT
第二条打印代码分析：* – ++cpp+3，前面cpp已经++了，现在cpp指向的是c+2的地址，加法的优先级比较低，++ – 的优先级比较高，顺序就是先算加加再解引用，再算–，再解引用，最后算+3.cpp先++，代表的是c+1的地址，进行解引用后代表c+1然后–，代表的是c,解引用后 c代表的是"ENTER"的首元素‘E’的地址，然后加3代表的是后面’E’的地址，然后打印出来的结果就是ER。
第三条打印代码分析：cpp[-2]+3。 cpp[-2]等价于 （cpp-2）,cpp现在是代表c+1的地址，-2后代表c+3的地址，进行解引用后代表c+3，c+3，进行解引用 * （c+3）代表的是”FIRST“的首元素‘F’地址，然后+3代表的是‘S’的地址，最后打印出来的结果就是ST
第四条打印代码分析：cpp[-1][-1] + 1。cpp现在代表的是c+1的地址，cpp[-1][-1]等价于 (* (cpp-1)-1)，即代表“NEW”首元素’N’的地址，然后+1即‘W’的地址，最后打印出来的结果就是EW。

总结

本文主要介绍strlen与sizeof的区别，利于strlen与sizeof来对比一维数组，字符数组以及二维数组，加深理解数组之间的区别与联系，最后讲解几个复杂指针的运算，如有错误请批评指正，感谢支持

南宫云落 kk
关注
  • 37
    点赞
  • 踩
  • 19
    收藏
    觉得还不错? 一键收藏
  • 5
    评论
(完整版)最全的C语言指针详解.ppt
11-13
本资源是一个详细的C语言指针指南，涵盖了指针的定义、使用、与函数、数组、字符串、动态内存分配的关系等方面的知识点。 指针是C语言中一个基本概念，它允许程序员直接访问和操作内存中的变量。指针可以分为两种：...
C语言指针知识点大全
2302_78964455的博客
03-07 1257
数组指针是指针？还是数组？答案是：指针。我们已经熟悉： 整形指针： int * pint;能够指向整形数据的指针。浮点型指针： float * pf;能够指向浮点型数据的指针。那数组指针应该是：能够指向数组的指针。下面代码哪个是数组指针？//p1, p2分别是什么？解释://解释：p先和*结合，说明p是一个指针变量，然后指着指向的是一个大小为10个整型的数组。//所以p是一个指针，指向一个数组，叫数组指针。//这里要注意：[]的优先级要高于*号的，所以必须加上（）来保证p先和*结合。OK!
C语言指针相关知识（第一篇章）（非常详细版）
m0_74949249的博客
05-09 952
本文初步引人了指针的概念，并对指针的一些基本知识做了概括，并提了一下野指针的问题，最后讲了一下传值调用与传址调用的区别以及指针在其中发挥的作用，我们要知道指针知识博大精深，这篇文章只是冰山一角呀，后期会出后面极板，一共打算出5版指针相关的文章，每一章节各有千秋。提示：以下是本篇文章正文内容，下面案例可供参考计算机中的内存就是数据存储的地方。我们知道计算机上CPU（中央处理器）在处理数据的时候，需要的数据是在内存中读取的，处理后的数据也会放回内存中。
C语言指针详解(经典,非常详细)
热门推荐
u013728021的博客
06-11 1万+
原文：https://blog.csdn.net/constantin_/article/details/79575638 前言:复杂类型说明 要了解指针,多多少少会出现一些比较复杂的类型,所以我先介绍一下如何完全理解一个复杂类型,要理解复杂类型其实很简单,一个类型里会出现很多运算符,他们也像普通的表达式一样,有优先级,其优先级和运算优先级一样,所以我总结了一下其原则:从变量名处起,根据运算符优先...
【转】【c基础知识】C指针详解(经典,非常详细)
lucifa_li的博客
05-11 3835
【c基础知识】C指针详解(经典,非常详细)2017年10月12日 20:43:10 阅读数：2593 前言:复杂类型说明    要了解指针,多多少少会出现一些比较复杂的类型,所以我先介绍一下如何完全理解一个复杂类型,要理解复杂类型其实很简单,一个类型里会出现很多运算符,他们也像普通的表达式一样,有优先级,其优先级和运算优先级一样,所以我总...
C语言教程第讲-指针引用类型声明完美版资料.ppt
11-18
C语言教程第讲-指针引用类型声明完美版资料.ppt 本讲内容主要包括指针、引用、字符串处理、typedef声明类型、循环语句等知识点。 一、指针 指针是一种特殊的变量，它可以存储其他变量的内存地址。指针变量的声明...
c语言程序设计第五版习题答案.doc
11-28
"C语言程序设计第五版习题答案" 中的知识点总结 一、C 语言概述 * C 语言的主要特点： + 语言简洁、紧凑，使用方便、灵活 + 数据类型丰富，表达能力强 + 运算符多样 + 具有结构化的控制语句 + 允许直接访问...
第讲-C语言二维数组与指针优秀文档.ppt
11-14
C语言二维数组与指针知识点总结 二维数组是C语言中一种重要的数据结构，它可以用来存储大量的数据，并且可以实现矩阵操作。二维数组的定义形式为：数据类型 数组名[常量表达式1][常量表达式2]，其中数组名是数组的...
(完整版)C语言知识点总结完美版.doc
11-15
C语言是计算机编程语言的基础，它的知识点总体上可以分为程序结构、数据类型、运算符、控制结构、函数、数组、指针、文件操作等几个方面。 一、程序结构 * 程序结构有三种：顺序结构、选择结构（分支结构）、循环...
【2024最新华为OD-C/D卷试题汇总】[支持在线评测] 连续区间和(100分) - 三语言AC题解(Python/Java/Cpp)
清隆学长的博客
06-14 81
YA 在分析一组数据时，需要统计出有多少个连续区间（包括单个元素）的和大于等于给定的阈值 $x$。现在他将这个任务交给你，请你帮忙计算出满足条件的连续区间的数量。 ### 输入格式 第一行包含两个整数 $n$ 和 $x$，分别表示数组的长度和阈值。 第二行包含 $n$ 个正整数，表示给定的数组。 ### 输出格式 输出一个整数，表示满足条件的连续区间的数量。 ### 样例输入1 ``` 3 7 3 4 7 ``` ### 样例输出1 ``` 4 ``` ###
为什么选择Python作为AI开发语言
AI心易行者
06-09 1861
综上所述，Python因其简洁易读的语法、丰富的库和框架、广泛的社区支持、适合快速原型开发的特性以及良好的兼容性和集成性，成为AI开发的首选语言。而像PlugLink这样的工具，则进一步提升了Python在AI开发中的效率和便利性。对于任何希望在AI领域有所作为的开发者来说，掌握Python无疑是必不可少的技能。在未来，随着AI技术的不断发展和进步，Python必将继续扮演重要角色，推动这一领域的创新和变革。如果你还没有开始学习Python，那么现在就是最好的时机。
数据库管理工具:dbeaver-ce-23.1.5-macos-aarch64.dmg
06-16
1.DBeaver是一款通用数据库工具，专为开发人员和数据库管理员设计。 2.DBeaver支持多种数据库系统，包括但不限于MySQL、PostgreSQL、Oracle、DB2、MSSQL、Sybase、Mimer、HSQLDB、Derby、SQLite等，几乎涵盖了市场上所有的主流数据库。 3.支持的操作系统：包括Windows（2000/XP/2003/Vista/7/10/11）、Linux、Mac OS、Solaris、AIX、HPUX等。 4.主要特性： 数据库管理：支持数据库元数据浏览、元数据编辑（包括表、列、键、索引等）、SQL语句和脚本的执行、数据导入导出等。 用户界面：提供图形界面来查看数据库结构、执行SQL查询和脚本、浏览和导出数据，以及处理BLOB/CLOB数据等。用户界面设计简洁明了，易于使用。 高级功能：除了基本的数据库管理功能外，DBeaver还提供了一些高级功能，如数据库版本控制（可与Git、SVN等版本控制系统集成）、数据分析和可视化工具（如图表、统计信息和数据报告）、SQL代码自动补全等。
一份关于信号与系统的大纲教程！！！！！！！！！！！！！
06-16
一份关于信号与系统的大纲教程！！！！！！！！！！！！！
【课件】7.5.1散列表的基本概念.pdf
06-16
【课件】7.5.1散列表的基本概念
【课件】8.7.4置换-选择排序.pdf
06-16
【课件】8.7.4置换-选择排序
Delphi 12 控件之unidac-10.2.1-d29pro.exe
06-16
unidac_10.2.1_d29pro.exe
基于STM32的微控制器的C++语言研究项目
06-16
此代码是基于 C、C++ 语言的 stm32 为微控制器编写的。 代码包含单独的部分：main、ini、USART code_for_display。 ADC_ini（模数转换器）是关于初始化ADC的。每当您触发模拟输入以开始转换时，它都会对模拟输入进行采样。它执行一个称为量化的过程，以决定电压电平及其在输出寄存器中推送的二进制代码。 USART（通用异步接收器-发射器）是一种外围通信硬件设备，它允许计算机通过 wifi 或蓝牙与串行连接的设备进行同步和异步通信。 code_for_display部分是包含 7 段显示的代码。 main 初始化ADC_ini，USART，code_for_display并开始接收信息的循环，显示它，将其发送到另一个设备，重复
数据库表结构同步工具.zip
最新发布
06-16
大学生数据结构学习笔记和资料大全！
数据库管理工具:dbeaver-ce-23.2.1-x86-64-setup.exe
06-16
1.DBeaver是一款通用数据库工具，专为开发人员和数据库管理员设计。 2.DBeaver支持多种数据库系统，包括但不限于MySQL、PostgreSQL、Oracle、DB2、MSSQL、Sybase、Mimer、HSQLDB、Derby、SQLite等，几乎涵盖了市场上所有的主流数据库。 3.支持的操作系统：包括Windows（2000/XP/2003/Vista/7/10/11）、Linux、Mac OS、Solaris、AIX、HPUX等。 4.主要特性： 数据库管理：支持数据库元数据浏览、元数据编辑（包括表、列、键、索引等）、SQL语句和脚本的执行、数据导入导出等。 用户界面：提供图形界面来查看数据库结构、执行SQL查询和脚本、浏览和导出数据，以及处理BLOB/CLOB数据等。用户界面设计简洁明了，易于使用。 高级功能：除了基本的数据库管理功能外，DBeaver还提供了一些高级功能，如数据库版本控制（可与Git、SVN等版本控制系统集成）、数据分析和可视化工具（如图表、统计信息和数据报告）、SQL代码自动补全等。
c语言指针基础知识点
11-15
以下是C语言指针的基础知识点： 1.指针的定义和初始化 指针是一个变量，其值为另一个变量的地址。定义指针变量时需要指定指针所指向的变量类型，然后使用*运算符来声明指针变量。指针变量的初始化可以为其赋值为另...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 5
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值