C语言之深入理解指针（5）

1. sizeof和strlen的对比

sizeof

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

sizeof只关注占用内存空间的大小，不在乎内存中存放什么数据。

int main()
{
	int a = 10;
	printf("%zd\n", sizeof(a));//4
	printf("%d\n", sizeof(int));//4
	printf("%zd\n", sizeof a);//这里可以省略括号

	int arr1[4] = { 0 };
	char arr2[4] = { 0 };
	printf("%d\n", sizeof(arr1));//16
	printf("%d\n", sizeof(arr2));//4

}
1
2
3
4
5
6
7
8
9
10
11
12
13

strlen

strlen是C语言库函数，功能是求字符串长度。函数原型如下：

size_t strlen ( const char * str);

统计的是从strlen函数的参数str中这个地址开始向后，\0之前字符串中字符的个数。

strlen函数会一直向后找\0字符，直到找到为止，所以可能存在越界查找。

int main()
{
	char arr[] = "abcdef";
	size_t len = strlen(arr);
	printf("%d\n", len);//6

	size_t sz = sizeof(arr);
	printf("%d\n", sz);//7 

	char arr[] = { 'a','b','c' };
	printf("%zd\n", strlen(arr));//随机值
	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13

sizeof和strlen的对比

sizeof

1. sizeof是操作符
2. sizeof计算操作数所占内存的大小，单位是字节
3. 不关注内存中存放什么数据
4. sizeof不挑类型

strlen

1. strlen是库函数，使用需要包括头文件string.h
2. strlen是求字符串长度的，统计的是\0之前字符的隔个数
3. 关注内存中是否有\0,如果没有\0，就会持续往后找，可能会越界
4. 只针对字符串

2. 数组和指针题目解析

一维数组

int main()
{
	int a[] = { 1,2,3,4 };//a数组有4个元素，每个元素是int类型的数据
	printf("%zd\n", sizeof(a));//16--计算的是整个数组的大小，单位是字节
	printf("%zd\n", sizeof(a + 0));// 4/8  a表示的就是数组首元素的地址 ,a+0还是首元素的地址
	printf("%zd\n", sizeof(*a));//4个字节  a表示的就是数组首元素的地址,*a就是首元素
	printf("%zd\n", sizeof(a + 1));// 4/8   a表示的就是数组首元素的地址,a+1就是第二个元素的地址，这里计算的是第二个元素的地址的大小
	printf("%zd\n", sizeof(a[1]));//4   a[1]是数组的第二个元素，大小是4个字节
	printf("%zd\n", sizeof(&a));// 4/8  &a-取出的是数组的地址，但是数组的地址也是地址，是地址，大小就是4/8个字节
	printf("%zd\n", sizeof(*&a));// 16  sizeof(a)-16
	//1.&和*抵消掉
	//2.&a的类型是数组指针，int(*)[4],*&a就是对数组指针解引用访问一个数组的大小，是16个字节
	printf("%zd\n", sizeof(&a + 1));// 4/8  &a+1是跳过整个数组后的一个地址，是地址，大小就是4/8个字节
	printf("%zd\n", sizeof(&a[0]));// 4/8   &a[0]是数组第一个元素的地址，大小是4/8个字节
	printf("%zd\n", sizeof(&a[0]+1));// 4/8  &a[0]+1是第二个元素的地址,大小就是4/8个字节
	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

数组名的意义：

数组名一般表示数组首元素的地址
但是有两个例外

1. sizeof（数组名），这里的数组名表示整个数组，计算的是整个数组的大小，单位是字节
2. &数组名，这里的数组名表示整个数组，取出的是整个数组的地址
3. 除此之外所有的数组名都表示首元素的地址

字符数组

代码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));// 4/8  arr+0是数组第一个元素的地址
	printf("%d\n", sizeof(*arr));// 1  *arr是首元素，计算的是首元素大小
	printf("%d\n", sizeof(arr[1]));// 1  arr[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;
}
1
2
3
4
5
6
7
8
9
10
11
12

代码2

int main()
{
	char arr[] = { 'a','b','c','d','e','f' };
	printf("%d\n", strlen(arr));//随机值
	printf("%d\n", strlen(arr + 0));//随机值
	printf("%d\n", strlen(*arr));//err  'a'-97
	printf("%d\n", strlen(arr[1]));//err   'b'-98
	printf("%d\n", strlen(&arr));//随机值
	printf("%d\n", strlen(&arr + 1));//随机值
	printf("%d\n", strlen(&arr[0] + 1));//随机值
}
1
2
3
4
5
6
7
8
9
10
11

代码3

int main()
{
	char arr[] = "abcdef";
	printf("%d\n", sizeof(arr));// 7
	printf("%d\n", sizeof(arr + 0));// 4/8  arr+0是数组首元素的地址
	printf("%d\n", sizeof(*arr));// 1  *arr是数组的首元素，这里计算的是首元素的大小
	printf("%d\n", sizeof(arr[1]));//1
	printf("%d\n", sizeof(&arr));// 4/8  &arr是数组的地址，数组的地址也是地址
	printf("%d\n", sizeof(&arr + 1));// 4/8  &arr+1，跳过整个数组，指向数组的后面
	printf("%d\n", sizeof(&arr[0] + 1));// 4/8   &arr[0] + 1,是第二个元素的地址
}
1
2
3
4
5
6
7
8
9
10
11

代码4

int main()
{
	char arr[] = "abcdef";// 6
	printf("%d\n", strlen(arr));// 6  arr是数组首元素的地址
	printf("%d\n", strlen(arr + 0));//6  arr+0是数组首元素的地址
	printf("%d\n", strlen(*arr));//err  传递的是'a'->97
	printf("%d\n", strlen(arr[1]));//err
	printf("%d\n", strlen(&arr));//6
	printf("%d\n", strlen(&arr + 1));//随机值
	printf("%d\n", strlen(&arr[0] + 1));//5
}
1
2
3
4
5
6
7
8
9
10
11

代码5

int main()
{
	char* p = "abcdef";
	printf("%d\n", sizeof(p));// 4/8  计算p指针变量的大小
	printf("%d\n", sizeof(p + 1));// 4/8  p+1是b的地址
	printf("%d\n", sizeof(*p));//*p就是'a',大小是1字节
	printf("%d\n", sizeof(p[0]));//p[0]--> *(p+0)-*p,1字节
	printf("%d\n", sizeof(&p));//&p也是地址，是指针变量p的地址，是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字节
}
1
2
3
4
5
6
7
8
9
10
11

代码6

int main()
{
	char* p = "abcdef";
	printf("%d\n", strlen(p));//6
	printf("%d\n", strlen(p + 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
}
1
2
3
4
5
6
7
8
9
10
11

二维数组

int main()
{
	//二维数组也是数组，之前对数组名理解也是合适的
	int a[3][4] = { 0 };
	printf("%d\n", sizeof(a));//12*4=48个字节，数组名单独放在sizeof内部
	printf("%d\n", sizeof(a[0][0]));//4
	printf("%d\n", sizeof(a[0]));//16字节  是第一行这个一维数组的数组名，数组名单独放在sizeof内部，计算第一行的大小了
	printf("%d\n", sizeof(a[0] + 1));//a[0]第一行这个一维数组的数组名，这里表示数组首元素，也就是a[0][0]的地址，a[0]+1是a[0][1]的地址
	printf("%d\n", sizeof(*(a[0] + 1)));//4  a[0][1]
	printf("%d\n", sizeof(a + 1));// 4/8  a是二维数组的数组名，但是没有&，也没有单独放在sizeof内部，所以这里的a是数组首元素的地址，应该是第一行的地址,a+1是第二行的地址
	printf("%d\n", sizeof(*(a + 1)));// 16个字节  *(a+1)---a[1]-第二行的数组名，单独放在sizeof内部，计算的是第二行的大小
	printf("%d\n", sizeof(&a[0] + 1));// 4/8  &a[0]是第一行的地址，&a[0]+1就是第二行的地址
	printf("%d\n", sizeof(*(&a[0] + 1)));//16个字节 访问的是第二行，计算的是第二行的大小
	printf("%d\n", sizeof(*a));// 16  这里的a是第一行的地址，*a就是第一行，sizeof(*a)计算的是第一行的大小
	printf("%d\n", sizeof(a[3]));// 16  这里不存在越界，因为sizeof内部的表达式是不会真实运算的，计算的是第四行的大小-16
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

3. 指针运算笔试题解析

题目1

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

题目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);//0x100014
	printf("%p\n", (unsigned long)p + 0x1);//0x100001
	printf("%p\n", (unsigned int*)p + 0x1);//0x100004
	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

题目3

int main()
{
	//注意逗号表达式
	int a[3][2] = { (0, 1), (2, 3), (4, 5) };//-->{1,3,5}
	int* p;
	p = a[0];
	printf("%d", p[0]);//1
	return 0;
}
1
2
3
4
5
6
7
8
9

代码4

//假设环境是x86环境，程序输出的结果是啥？ 
int main()
{
	int a[5][5];
	int(*p)[4];		//p是数组指针，指向的数组4个int类型的元素
	p = a;
	printf("%p,%d\n", &p[4][2] - &a[4][2], &p[4][2] - &a[4][2]);//FFFFFFFC,-4
	return 0;
}
1
2
3
4
5
6
7
8
9

代码5

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));//10,5
	return 0;
}
1
2
3
4
5
6
7
8

题目6

int main()
{
	char* a[] = { "work","at","alibaba" };
	char** pa = a;
	pa++;
	printf("%s\n", *pa);//at
	return 0;
}
1
2
3
4
5
6
7
8

题目7

int main()
{
	char* c[] = { "ENTER","NEW","POINT","FIRST" };
	char** cp[] = { c + 3,c + 2,c + 1,c };
	char*** cpp = cp;
	printf("%s\n", **++cpp);//POINT
	printf("%s\n", *-- * ++cpp + 3);//ER
	printf("%s\n", *cpp[-2] + 3);//3
	printf("%s\n", cpp[-1][-1] + 1);//EW
	return 0;
}
1
2
3
4
5
6
7
8
9
10
11