深⼊理解指针(含指针笔试题)

深⼊理解指针

    • 1. sizeof和strlen的对比
      • 1.1 sizeof
      • 1.2 strlen
      • 1.3 sizeof 和 strlen的对⽐
    • 2. 数组和指针笔试题解析
      • 2.1 ⼀维数组
      • 2.2 字符数组
      • 2.3 ⼆维数组
    • 3. 指针运算笔试题解析
      • 3.1 题⽬1
      • 3.2 题⽬7

1. sizeof和strlen的对比

1.1 sizeof

在学习操作符的时候,我们学习了 sizeof , sizeof 计算变量所占内存内存空间⼤⼩的,单位是字节,如果操作数是类型的话,计算的是使⽤类型创建的变量所占内存空间的⼤⼩

sizeof 只关注占⽤内存空间的⼤⼩,不在乎内存中存放什么数据。

⽐如:

#include 
int main()
{
	int a = 10;
	printf("%d\n", sizeof(a));
	printf("%d\n", sizeof a);
	printf("%d\n", sizeof(int));

	return 0;
}

深⼊理解指针(含指针笔试题)_第1张图片

1.2 strlen

strlen 是C语⾔库函数,功能是求字符串⻓度。函数原型如下:

size_t strlen ( const char * str );

统计的是从 strlen 函数的参数 str 中这个地址开始向后, \0 之前字符串中字符的个数。strlen 函数会⼀直向后找 \0 字符,直到找到为⽌,所以可能存在越界查找。

#include 
int main()
{
	char arr[] = "abcdef";
	size_t len = strlen(arr);
	printf("%zd\n", len);

	return 0;
}

运行结果如图:深⼊理解指针(含指针笔试题)_第2张图片

#include 
int main()
{
 char arr1[3] = {'a', 'b', 'c'};
 char arr2[] = "abc";
 printf("%d\n", strlen(arr1));
 printf("%d\n", strlen(arr2));
 
 printf("%d\n", sizeof(arr1));
 printf("%d\n", sizeof(arr1));
 return 0;
}

运行结果如图:
深⼊理解指针(含指针笔试题)_第3张图片

1.3 sizeof 和 strlen的对⽐

sizeof strlen
sizeof是操作符 strlen是库函数,使⽤需要包含头⽂件 string.h
sizeof计算操作数所占内存的⼤⼩,单位是字节 srtlen是求字符串⻓度的,统计的是 \0 之前字符的隔个数
不关注内存中存放什么数据 关注内存中是否有 \0 ,如果没有 \0 ,就会持续往后找,可能会越界

2. 数组和指针笔试题解析

2.1 ⼀维数组

//但是有2个例外:
//1. sizeof(数组名),数组名表示整个数组,计算的是整个数组的大小,单位是字节
//2. &数组名,数组名表示整个数组,取出的数组的地址
//除此之外,所有遇到的数组名都是数组首元素的地址

int main()
{
	int a[] = { 1,2,3,4 };//a数组有4个元素,每个元素是int类型的数据

	printf("%zd\n", sizeof(a));//16 - sizeof(数组名)的情况,计算的是整个数组的大小,单位是字节 - 16
	printf("%zd\n", sizeof(a + 0));//a表示的就是数组首元素的地址,a+0还是首元素的地址 - 4/8
	//int*
	printf("%zd\n", sizeof(*a));//a表示的就是数组首元素的地址,*a 就是首元素,大小就是4个字节
	printf("%zd\n", sizeof(a + 1));//a表示的就是数组首元素的地址,a+1就是第二个元素的地址,
	//这里的计算的是第二个元素的地址的大小-4/8

	printf("%zd\n", sizeof(a[1]));//a[1]是数组的第二个元素,大小是4个字节
	printf("%zd\n", sizeof(&a));//&a - 取出的是数组的地址,但是数组的地址也是地址,是地址,大小就是4/8个字节
	//int (*pa)[4] = &a
	//int(*)[4]
	printf("%zd\n", sizeof(*&a));//sizeof(a) -16
	//1. & 和 * 抵消
	//2.&a 的类型是数组指针,int(*)[4],*&a就是对数组指针解引用访问一个数组的大小,是16个字节

	printf("%zd\n", sizeof(&a + 1));//&a+1是跳过整个数组后的一个地址,是地址,大小就是4/8个字节

	printf("%zd\n", sizeof(&a[0]));//&a[0]是数组第一个元素的地址,大小就是4/8个字节
	printf("%zd\n", sizeof(&a[0] + 1));//&a[0] + 1 是第二个元素的地址,大小就是4/8个字节
	                      //int*
	return 0;
}

2.2 字符数组

代码1:

int main()
{
	char arr[] = { 'a','b','c','d','e','f' };//arr数组中有6个元素

	printf("%d\n", sizeof(arr));//计算的是整个数组的大小,6个字节
	printf("%d\n", sizeof(arr + 0));//arr+0 是数组第一个元素的地址 4/8
	printf("%d\n", sizeof(*arr));//*arr是首元素,计算的是首元素的大小,就是1个字节
	printf("%d\n", sizeof(arr[1]));//arr[1]  - 1
	printf("%d\n", sizeof(&arr));//4/8
	printf("%d\n", sizeof(&arr + 1));//4/8
	printf("%d\n", sizeof(&arr[0] + 1));//4/8

	return 0;
}

代码2:

int main()
{
	char arr[] = { 'a','b','c','d','e','f' };
	printf("%d\n", strlen(arr));//随机值
	printf("%d\n", strlen(arr + 0));//随机值
	//'a'-97
	printf("%d\n", strlen(*arr));//err
					   //'b'-98
	printf("%d\n", strlen(arr[1]));//err
	printf("%d\n", strlen(&arr));//随机值
	printf("%d\n", strlen(&arr + 1));//随机值
	printf("%d\n", strlen(&arr[0] + 1));//随机值

	return 0;
}

代码3:

int main()
{
	char arr[] = "abcdef";

	printf("%zd\n", sizeof(arr));//7
	printf("%zd\n", sizeof(arr + 0));//arr+0是数组首元素的地址,地址的大小是4/8个字节
	printf("%zd\n", sizeof(*arr));//*arr是数组的首元素,这里计算的是首元素的大小 1
	printf("%zd\n", sizeof(arr[1]));//1
	printf("%zd\n", sizeof(&arr));//&arr - 是数组的地址,数组的地址也是地址,是地址就是4/8个字节
	printf("%zd\n", sizeof(&arr + 1));//&arr+1,跳过整个数组,指向了数组的后边,4/8
	printf("%zd\n", sizeof(&arr[0] + 1));//&arr[0] + 1是第二个元素的地址 4/8

	return 0;
}

代码4:

int main()
{
	char arr[] = "abcdef";

	printf("%zd\n", strlen(arr));//arr是数组首元素的地址 6
	printf("%zd\n", strlen(arr + 0));//arr + 0是数组首元素的地址,6
	//printf("%zd\n", strlen(*arr));//传递是'a'-97,//err
	//printf("%zd\n", strlen(arr[1]));//'b'-98//err
	printf("%zd\n", strlen(&arr));//6, &arr虽然是数组的地址,但是也是指向数组的起始位置
	printf("%zd\n", strlen(&arr + 1));//随机值
	printf("%zd\n", strlen(&arr[0] + 1));//&arr[0] + 1是第二个元素的地址 - 5

	return 0;
}

代码5:

int main()
{
	char* p = "abcdef";
	printf("%zd\n", sizeof(p));//4/8 计算的指针变量的大小
	printf("%zd\n", sizeof(p + 1));//p + 1是'b'的地址,是地址大小就是4/8个字节
	printf("%zd\n", sizeof(*p));//*p就是'a',大小是1个字节
	printf("%zd\n", sizeof(p[0]));//p[0]--> *(p+0) - *p //1字节
	printf("%zd\n", sizeof(&p));//&p也是地址,是指针变量p的地址,大小也是4/8个字节
	printf("%zd\n", sizeof(&p + 1));//&p + 1是指向p指针变量后面的空间,也是地址,是4/8个字节
	printf("%zd\n", sizeof(&p[0] + 1));//&p[0]+1是'b'的地址,是地址就是4/8个字节

	return 0;
}

代码6:

int main()
{
	char* p = "abcdef";

	printf("%zd\n", strlen(p));//6
	printf("%zd\n", strlen(p + 1));//5
	//printf("%zd\n", strlen(*p));//err
	//printf("%zd\n", strlen(p[0]));//p[0]--*(p+0)-->*p //err
	printf("%zd\n", strlen(&p));//随机值
	printf("%zd\n", strlen(&p + 1));//随机值
	printf("%zd\n", strlen(&p[0] + 1));//5

	return 0;
}

2.3 ⼆维数组

int main()
{
	//二维数组也是数组,之前对数组名理解也是适合
	int a[3][4] = { 0 };
	printf("%zd\n", sizeof(a));//12*4 = 48个字节,数组名单独放在sizeof内部
	printf("%zd\n", sizeof(1));
	printf("%zd\n", sizeof(a[0][0]));//4
	printf("%zd\n", sizeof(a[0]));//a[0]是第一行这个一维数组的数组名,数组名单独放在sizeof内部了
	//计算的是第一行的大小,单位是字节,16个字节

	printf("%zd\n", sizeof(a[0] + 1));//a[0]第一行这个一维数组的数组名,这里表示数组首元素
	//也就是a[0][0]的地址,a[0] + 1是a[0][1]的地址 4/8

	printf("%zd\n", sizeof(*(a[0] + 1)));//a[0][1] - 4个字节
	printf("%zd\n", sizeof(a + 1));//a是二维数组的数组名,但是没有&,也没有单独放在sizeof内部
	//所以这里的a是数组收元素的地址,应该是第一行的地址,a+1是第二行的地址
	//大小也是4/8 个字节
	
	printf("%zd\n", sizeof(*(a + 1)));//*(a + 1) ==> a[1] - 第二行的数组名,
	//单独放在sizeof内部,计算的是第二行的大小
	//16个字节
	
	printf("%zd\n", sizeof(&a[0] + 1));//&a[0]是第一行的地址,&a[0]+1就是第二行的地址,4/8
	printf("%zd\n", sizeof(*(&a[0] + 1)));//访问的是第二行,计算的是第二行的大小,16个字节
	//int(*p)[4] = &a[0] + 1;
	
	printf("%zd\n", sizeof(*a));//这里的a是第一行的地址,*a就是第一行,sizeof(*a)计算的是第一行的大小-16
	//*a --> *(a+0) --> a[0]
	
	printf("%zd\n", sizeof(a[3]));//这里不存在越界
	//因为sizeof内部的表达式不会真实计算的
	//计算的是第四行的大小-16

	return 0;
}

数组名的意义:

  1. sizeof(数组名),这⾥的数组名表⽰整个数组,计算的是整个数组的⼤⼩。
  2. &数组名,这⾥的数组名表⽰整个数组,取出的是整个数组的地址。
  3. 除此之外所有的数组名都表⽰⾸元素的地址。

3. 指针运算笔试题解析

3.1 题⽬1

//假设环境是x86环境,程序输出的结果是啥?
#include 
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;
}

运行结果:
深⼊理解指针(含指针笔试题)_第4张图片
画图分析:
深⼊理解指针(含指针笔试题)_第5张图片
因为%p打印的无符号的16进制的结果,所以,-4会被当成当成一个无符号的数来看待

//-4
//10000000000000000000000000000100 - -4的原码
//11111111111111111111111111111011 - -4的反码
//1111 1111 1111 1111 1111 1111 1111 1100 - -4的补码
// F    F    F    F    F    F    F     C

3.2 题⽬7

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

运行结果:
深⼊理解指针(含指针笔试题)_第6张图片
画图分析:
深⼊理解指针(含指针笔试题)_第7张图片

你可能感兴趣的:(c语言,开发语言,vscode)