浅学指针(5)sizeof和strlen的进阶理解

系列文章目录


文章目录

  • 系列文章目录
  • 前言
  • 1. sizeof和strlen的对⽐
    • 1.1 sizeof
    • sizeof不是函数,是运算符
  • 1.2 strlen
    • 1.3 sizeof 和 strlen的对⽐
  • 2. 数组和指针笔试题解析
    • • sizeof(数组名),sizeof中单独放数组名,这⾥的数组名表⽰整个数组,计算的是整个数组的⼤⼩, 单位是字节 • &数组名,这⾥的数组名表⽰整个数组,取出的是整个数组的地址(整个数组的地址和数组⾸元素 的地址是有区别的) 除此之外,任何地⽅使⽤数组名,数组名都表⽰⾸元素的地址。
    • 2.1 ⼀维数组
    • 2.2 字符数组
    • 代码4: 这里有重要内容
    • strlen计算内容是地址时,计算的是地址的内容
  • 2.3 ⼆维数组
  • 3. 指针运算笔试题解析
    • 3.2 题⽬2
    • #的作用打印Ox前缀
    • 3.3 题⽬3
    • 3.4 题⽬4
    • 3.5 题⽬5
    • 做这种题最好画图
    • 3.6 题⽬6
    • 3.7 题⽬7


前言

目的:深入学习sizeof和strlen和有关2维数组的指针形式

1. sizeof和strlen的对⽐

1.1 sizeof

在学习操作符的时候,我们学习了 sizeof , sizeof 计算变量所占内存内存空间⼤⼩的,单位是字节,如果操作数是类型的话,计算的是使⽤类型创建的变量所占内存空间的⼤⼩。sizeof 只关注占⽤内存空间的⼤⼩,不在乎内存中存放什么数据。
⽐如:

sizeof不是函数,是运算符

#inculde <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,

1.2 strlen

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

	size_t strlen ( const char * str );

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

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

代码1:随机值,没有\0; 代码2:结果是3
代码3:结果3 代码4:结果是4

1.3 sizeof 和 strlen的对⽐

(1)sizeof

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

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

后面所有题都是在下面基础上:

• sizeof(数组名),sizeof中单独放数组名,这⾥的数组名表⽰整个数组,计算的是整个数组的⼤⼩,
单位是字节
• &数组名,这⾥的数组名表⽰整个数组,取出的是整个数组的地址(整个数组的地址和数组⾸元素
的地址是有区别的)
除此之外,任何地⽅使⽤数组名,数组名都表⽰⾸元素的地址。

2.1 ⼀维数组

写出所占字节数

	int a[] = {1,2,3,4};
	printf("%d\n",sizeof(a));//单单数组名,是整个数组,16
	printf("%d\n",sizeof(a+0));//首元素地址加0,为地址4/8个字节
	printf("%d\n",sizeof(*a));//为首元素内容,4
	printf("%d\n",sizeof(a+1));//首元素地址加1,为第2个元素地址 ,4/8
	printf("%d\n",sizeof(a[1]));//4
	printf("%d\n",sizeof(&a));//地址 4/8
	printf("%d\n",sizeof(*&a));//所有元素地址,解引用为所有元素内容,4*4=16
	printf("%d\n",sizeof(&a+1));//地址,4/8
	printf("%d\n",sizeof(&a[0]));//地址4/8
	printf("%d\n",sizeof(&a[0]+1));//首元素地址加1,第2个元素地址,4/8

2.2 字符数组

代码1:

	char arr[] = {'a','b','c','d','e','f'};
	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]));//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

代码2:

char arr[] = {'a','b','c','d','e','f'};
	printf("%d\n", strlen(arr));//随机值,因为没有\0
	printf("%d\n", strlen(arr+0));//随机值
	printf("%d\n", strlen(*arr));//err(错误)'b'没有\0
	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));//随机值

代码3:

	char arr[] = "abcdef";
	printf("%d\n", sizeof(arr));//7
	printf("%d\n", sizeof(arr+0));//arr+0是数组首元素的地址,地址的大小4/8
	printf("%d\n", sizeof(*arr));//*arr是数组首元素地址,1
	printf("%d\n", sizeof(arr[1]));//1
	printf("%d\n", sizeof(&arr));//整个数组地址,数组地址也是地址4/8
	printf("%d\n", sizeof(&arr+1));//&arr+1跳过整个数组,指向了数组的后,4/8
	printf("%d\n", sizeof(&arr[0]+1));//&arr[0]+1是第2个元素地址4/8

代码4:
这里有重要内容

	char arr[] = "abcdef";
	printf("%d\n", strlen(arr));//6
	printf("%d\n", strlen(arr+0));//arr+0是首元素地址,6
	printf("%d\n", strlen(*arr));//err(错误)
	printf("%d\n", strlen(arr[1]));//err'b'没有\0
	printf("%d\n", strlen(&arr));//————&arr虽然是数组地址,但是也是指向数组起始位置
	printf("%d\n", strlen(&arr+1));//随机值
	printf("%d\n", strlen(&arr[0]+1));//&arr+1是第2个元素的地址

strlen计算内容是地址时,计算的是地址的内容

代码5:

	char *p = "abcdef";
	printf("%d\n", sizeof(p));//p是指针变量,是地址4/8
	printf("%d\n", sizeof(p+1));//p+1是'b' 的地址,4/8
	printf("%d\n", sizeof(*p));//*p计算'a'大小1个字节
	printf("%d\n", sizeof(p[0]));//p[0] = *(p+0) 1个字节
	printf("%d\n", sizeof(&p));//&p是地址,这里相当于2级指针4/8
	printf("%d\n", sizeof(&p+1));//&p+1是指向p指针变量后面的空间,也是地址,是4/8字节
	printf("%d\n", sizeof(&p[0]+1));//&p[0]+1是'b'的地址,是地址就是4/8个字节

代码6:

	char *p = "abcdef";
	printf("%d\n", strlen(p));//6
	printf("%d\n", strlen(p+1));//跳过1个字节,计算后面的为5
	printf("%d\n", strlen(*p));//err
	printf("%d\n", strlen(p[0]));//err一个字节
	printf("%d\n", strlen(&p));//随机值
	printf("%d\n", strlen(&p+1));//随机值
	printf("%d\n", strlen(&p[0]+1));//5

2.3 ⼆维数组

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

数组名的意义:

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

3. 指针运算笔试题解析

3.1 题⽬1:

#include 
int main()
{
 	int a[5] = { 1, 2, 3, 4, 5 };
 	int *ptr = (int *)(&a + 1);
 	printf( "%d,%d", *(a + 1), *(ptr - 1));
 return 0;
}
//程序的结果是什么?

浅学指针(5)sizeof和strlen的进阶理解_第1张图片
*(ptr-1)解析:
浅学指针(5)sizeof和strlen的进阶理解_第2张图片

3.2 题⽬2

指针+整数

//在X86环境下
//假设结构体的⼤⼩是20个字节
//程序输出的结构是啥?
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);//0x100000+20 == x100014
 	printf("%p\n", (unsigned long)p + 0x1);//0x100000+1 == 0x100001
 	printf("%p\n", (unsigned int*)p + 0x1);//0x100000+1 == 0x100004
 	return 0;
}

结果:
浅学指针(5)sizeof和strlen的进阶理解_第3张图片
也可以以16进制打印:

struct Test
{
 	int Num;
 	char *pcName;
 	short sDate;
 	char cha[2];
 	short sBa[4];
}*p = (struct Test*)0x100000;
int main()
{
 	printf("%#x\n", p + 0x1);//0x100000+20 == x100014
 	printf("%#x\n", (unsigned long)p + 0x1);//0x100000+1 == 0x100001
 	printf("%#x\n", (unsigned int*)p + 0x1);//0x100000+1 == 0x100004
 	return 0;
}

#的作用打印Ox前缀

结果:
浅学指针(5)sizeof和strlen的进阶理解_第4张图片

3.3 题⽬3

重点看

#include 
int main()
{
 	int a[3][2] = { (0, 1), (2, 3), (4, 5) };//这里是(),是逗号表达式,不是{},逗号表达式结果是运算到最右边的结果
 	//int a[3][2] = { 1, 3, 5 };
 	int *p;
 	p = a[0];
 	printf( "%d", p[0]);
 	return 0;
}

分析:
浅学指针(5)sizeof和strlen的进阶理解_第5张图片
输出结果:
浅学指针(5)sizeof和strlen的进阶理解_第6张图片
为什么是1,其实是把a[0](数组第一行)给p,其实给的是第一行首元素地址。

3.4 题⽬4

//假设环境是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]);//-4,-4(元素个数)
 	return 0;
}

分析:
浅学指针(5)sizeof和strlen的进阶理解_第7张图片
浅学指针(5)sizeof和strlen的进阶理解_第8张图片
输出结果:
浅学指针(5)sizeof和strlen的进阶理解_第9张图片

3.5 题⽬5

#include 
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));//相当于a[1],第2行,ptr得到的是第2行首元素地址
 	printf( "%d,%d", *(ptr1 - 1), *(ptr2 - 1));
	return 0;
}

做这种题最好画图

浅学指针(5)sizeof和strlen的进阶理解_第10张图片

输出结果:
浅学指针(5)sizeof和strlen的进阶理解_第11张图片

3.6 题⽬6

#include 
int main()
{
 	char *a[] = {"work","at","alibaba"};//指针数组
 	char**pa = a;
 	pa++;
 	printf("%s\n", *pa);
 return 0;
}

分析:

浅学指针(5)sizeof和strlen的进阶理解_第12张图片

输出结果:
浅学指针(5)sizeof和strlen的进阶理解_第13张图片

3.7 题⽬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;
}

分析:
解引用cpp是找到cp[ ]里面的内容如:c + 3
浅学指针(5)sizeof和strlen的进阶理解_第14张图片
浅学指针(5)sizeof和strlen的进阶理解_第15张图片
输出结果:
浅学指针(5)sizeof和strlen的进阶理解_第16张图片
好了,指针的学习就到这里就结束了,都看到这里了,点一个赞,谢谢。

你可能感兴趣的:(C语言,指针,算法,c语言,学习)