浅学指针（5）sizeof和strlen的进阶理解

系列文章目录

---

---

前言

目的：深入学习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 <stdio.h>
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 <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;
}
//程序的结果是什么？

*（ptr-1)解析：

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

结果：

也可以以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前缀

结果：

3.3 题⽬3

重点看

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

分析：

输出结果：

为什么是1，其实是把a[0]（数组第一行）给p，其实给的是第一行首元素地址。

3.4 题⽬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]);//-4，-4（元素个数）
 	return 0;
}

分析：


输出结果：

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

做这种题最好画图

输出结果：

3.6 题⽬6

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

分析：

输出结果：

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

分析：
解引用cpp是找到cp[ ]里面的内容如：c + 3


输出结果：

好了，指针的学习就到这里就结束了，都看到这里了，点一个赞，谢谢。