第十讲：C语言指针（4）

1、回调函数是什么？

2、qsort使⽤举例

2.1、使⽤qsort函数排序整型数据

2.2、使⽤qsort排序结构数据

3、qsort函数的模拟实现

4、sizeof和strlen的对⽐

4.1、sizeof

4.2、strlen

4.3、sizeof 和 strlen的对⽐

5、数组和指针笔试题解析

5.1、⼀维数组

5.2、字符数组

5.3、⼆维数组

6、指针运算笔试题解析

6.1、题⽬1：

6.2、题⽬2

6.3、题⽬3

6.4、题⽬4

6.5、题⽬5

6.6、题⽬6

6.7、题⽬7

6.8、题目8

上一篇：C语言指针（3）

https://blog.csdn.net/yi_ren_yi_xin/article/details/138138355?spm=1001.2014.3001.5501

1、回调函数是什么？

回调函数就是⼀个通过函数指针调⽤的函数。

如果你把函数的指针（地址）作为参数传递给另⼀个函数，当这个指针被⽤来调⽤其所指向的函数时，被调⽤的函数就是回调函数。

回调函数不是由该函数的实现⽅直接调⽤，⽽是在特定的事件或条件发⽣时由另外的⼀⽅调⽤的，⽤于对该事件或条件进⾏响应。

例如：

//使⽤回到函数改造后
#include <stdio.h>
int add(int a, int b)
{
	return a + b;
}
int sub(int a, int b)
{
	return a - b;
}
int mul(int a, int b)
{
	return a * b;
}
int div(int a, int b)
{
	return a / b;
}
void calc(int(*pf)(int, int))
{
	int ret = 0;
	int x, y;
	printf("输入操作数：");
	scanf("%d %d", &x, &y);
	ret = pf(x, y);
	printf("ret = %d\n", ret);
}

int main()
{
	int input = 1;
	do
	{
		printf("*************************\n");
		printf(" 1:add 2:sub \n");
		printf(" 3:mul 4:div \n");
		printf(" 0:exit \n");
		printf("*************************\n");
		printf("请选择：");
		scanf("%d", &input);
		switch (input)
		{
		case 1:
			calc(add);
			break;
		case 2:
			calc(sub);
			break;
		case 3:
			calc(mul);
			break;
		case 4:
			calc(div);
			break;
		case 0:
			printf("退出程序\n");
			break;
		default:
			printf("选择错误\n");
			break;
		}
	} while (input);
	return 0;
}

2、qsort使⽤举例

使用前需要包含头文件，#include<stdlib.h>。

qsort函数的特点：

1、快速排序的方法。

2、适合于任意类型数据的排序。

qsort函数的第一个参数为需要排序数组的第一个元素的地址，第二个参数为排序元素的数量，第三个参数为一个元素的大小，单位是字节，第四个参数为一个指向函数的指针，这个函数能够比较第一个参数所指向的元素。

2.1、使⽤qsort函数排序整型数据

#include <stdio.h>
//qosrt函数的使⽤者得实现⼀个⽐较函数
int int_cmp(const void* p1, const void* p2)
{
	return (*(int*)p1 - *(int*)p2);//强制类型转换为我们要排序的类型
}
int main()
{
	int arr[] = { 1, 3, 5, 7, 9, 2, 4, 6, 8, 0 };
	int i = 0;
	qsort(arr, sizeof(arr) / sizeof(arr[0]), sizeof(int), int_cmp);

	for (i = 0; i < sizeof(arr) / sizeof(arr[0]); i++)
	{
		printf("%d ", arr[i]);
	}
	printf("\n");

	return 0;
}

在上面的代码中，使用void的原因是我们并不清楚传过来的实参会是什么类型的指针。

2.2、使⽤qsort排序结构数据

struct Stu //学⽣
{
	char name[20];//名字
	int age;//年龄
};

//假设按照年龄来⽐较
int cmp_stu_by_age(const void* e1, const void* e2)
{
	return ((struct Stu*)e1)->age - ((struct Stu*)e2)->age;
}

//strcmp - 是库函数，是专⻔⽤来⽐较两个字符串的⼤⼩的,要包含头文件sting.h
//假设按照名字来⽐较
int cmp_stu_by_name(const void* e1, const void* e2)
{
	return strcmp(((struct Stu*)e1)->name, ((struct Stu*)e2)->name);
}

//按照年龄来排序
void test2()
{
	struct Stu s[] = { {"zhangsan", 20}, {"lisi", 30}, {"wangwu", 15} };
	int sz = sizeof(s) / sizeof(s[0]);
	qsort(s, sz, sizeof(s[0]), cmp_stu_by_age);
}

//按照名字来排序
void test3()
{
	struct Stu s[] = { {"zhangsan", 20}, {"lisi", 30}, {"wangwu", 15} };
	int sz = sizeof(s) / sizeof(s[0]);
	qsort(s, sz, sizeof(s[0]), cmp_stu_by_name);
}

int main()
{
	test2();
	test3();
	return 0;
}

3、qsort函数的模拟实现

使⽤回调函数，模拟实现qsort。

1、使用冒泡排序的思想。

2、适用于任意类型数据的排序。

#include <stdio.h>
int int_cmp(const void* p1, const void* p2)
{
	return (*(int*)p1 - *(int*)p2);
}

void _swap(void* p1, void* p2, int size)
{
	int i = 0;
	for (i = 0; i < size; i++)
	{
		char tmp = *((char*)p1 + i);
		*((char*)p1 + i) = *((char*)p2 + i);
		*((char*)p2 + i) = tmp;
	}
}
void bubble(void* base, int count, int size, int(*cmp)(void*, void*))
{
	int i = 0;
	int j = 0;
	for (i = 0; i < count - 1; i++)
	{
		for (j = 0; j < count - i - 1; j++)
		{
			if (cmp((char*)base + j * size, (char*)base + (j + 1) * size) > 0)
			{
				_swap((char*)base + j * size, (char*)base + (j + 1) * size, size);
			}//在上面的代码中之所以转换为char*是因为void*类型无法进行任何运算。
			//此外，char*在参与运算时，是最小的一个单位，加或者减几个单位，它就相应的移动几个单位。
	    }
	}
}
int main()
{
	int arr[] = { 1, 3, 5, 7, 9, 2, 4, 6, 8, 0 };
	int i = 0;

	bubble(arr, sizeof(arr) / sizeof(arr[0]), sizeof(int), int_cmp);

	for (i = 0; i < sizeof(arr) / sizeof(arr[0]); i++)
	{
		printf("%d ", arr[i]);
	}
	printf("\n");
	return 0;
}

4、sizeof和strlen的对⽐

4.1、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.2、strlen

strlen 是C语⾔库函数，功能是求字符串⻓度。

统计的是从 strlen 函数的参数中这个地址开始向后， \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));

	printf("%d\n", sizeof(arr1));
	printf("%d\n", sizeof(arr2));
	return 0;
}

运行结果为：

4.3、sizeof 和 strlen的对⽐

sizeof ：

1. sizeof是操作符

2. sizeof计算操作数所占内存的⼤⼩，单位是字节

3. 不关注内存中存放什么数据

strlen：

1. strlen是库函数，使⽤需要包含头⽂件 string.h

2. srtlen是求字符串⻓度的，统计的是 \0 之前字符的隔个数

3. 关注内存中是否有 \0 ，如果没有 \0 ，就会持续往后找，可能会越界。

5、数组和指针笔试题解析

5.1、⼀维数组

#include<stdio.h>
int main()
{
	int a[] = { 1,2,3,4 };
	printf("%d\n", sizeof(a));//结果为16个字节
	printf("%d\n", sizeof(a + 0));//a+0在这里是指针，所以大小为4或者8个字节
	printf("%d\n", sizeof(*a));//首元素，所以是4个字节
	printf("%d\n", sizeof(a + 1));//指针，4或8个字节
	printf("%d\n", sizeof(a[1]));//4个字节
	printf("%d\n", sizeof(&a));//指针，4或8个字节
	printf("%d\n", sizeof(*&a));//16个字节，&a指向整个数组，解引用后代表整个数组
	printf("%d\n", sizeof(&a + 1));//指针，4或8个字节
	printf("%d\n", sizeof(&a[0]));//指针，4或者8个字节
	printf("%d\n", sizeof(&a[0] + 1));//指针，4或者8个字节
	return 0;
}

5.2、字符数组

代码1：

#include<stdio.h>
int main()
{
	char arr[] = { 'a','b','c','d','e','f' };
	printf("%d\n", sizeof(arr));//结果为6
	printf("%d\n", sizeof(arr + 0));//指针，结果为4或8个字节
	printf("%d\n", sizeof(*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个字节

	return 0;
}

代码2：

#include<stdio.h>
int main()
{
	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));//*arr表示数组首元素a，字符a的数值为97，从97这个地址向后统计\0 
                                  //之前的字符个数，错误
	printf("%d\n", strlen(arr[1]));//同上，错误
	printf("%d\n", strlen(&arr));//随机值
	printf("%d\n", strlen(&arr + 1));//随机值
	printf("%d\n", strlen(&arr[0] + 1));//随机值

	return 0;
}

代码3：

char arr[] = "abcdef";
printf("%d\n", sizeof(arr));//7个字节
printf("%d\n", sizeof(arr+0));//指针，4或者8个字节
printf("%d\n", sizeof(*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个字节

代码4：

char arr[] = "abcdef";
printf("%d\n", strlen(arr));//结果为6
printf("%d\n", strlen(arr+0));//结果为6
printf("%d\n", strlen(*arr));//错误
printf("%d\n", strlen(arr[1]));//错误
printf("%d\n", strlen(&arr));//结果为6
printf("%d\n", strlen(&arr+1));//结果为
printf("%d\n", strlen(&arr[0]+1));//结果为5

代码5：

char *p = "abcdef";
printf("%d\n", sizeof(p));//4或者8个字节
printf("%d\n", sizeof(p+1));//4或者8个字节
printf("%d\n", sizeof(*p));//1个字节
printf("%d\n", sizeof(p[0]));//1个字节
printf("%d\n", sizeof(&p));//指针，4或者8个字节
printf("%d\n", sizeof(&p+1));//4或者8字节
printf("%d\n", sizeof(&p[0]+1));//4或者8个字节

代码6：

char *p = "abcdef";
printf("%d\n", strlen(p));//6个
printf("%d\n", strlen(p+1));//5个
printf("%d\n", strlen(*p));//错误
printf("%d\n", strlen(p[0]));//错误
printf("%d\n", strlen(&p));//随机值
printf("%d\n", strlen(&p+1));//随机值
printf("%d\n", strlen(&p[0]+1));//5个

5.3、⼆维数组

int a[3][4] = {0};
printf("%d\n",sizeof(a));48个字节
printf("%d\n",sizeof(a[0][0]));//4个字节
printf("%d\n",sizeof(a[0]));//这个就相当于二维数组的第一行的一维数组的数组名，所以结果为16个字节
printf("%d\n",sizeof(a[0]+1));//这个就相当于第一行第二个元素的地址，4或者8个字节
printf("%d\n",sizeof(*(a[0]+1)));//4个字节
printf("%d\n",sizeof(a+1));//相当于第二行地址，4或者8个字节
printf("%d\n",sizeof(*(a+1)));//16个字节
printf("%d\n",sizeof(&a[0]+1));//地址，4或者8个字节
printf("%d\n",sizeof(*(&a[0]+1)));//16个字节
printf("%d\n",sizeof(*a));//数组的首元素，4个字节
printf("%d\n",sizeof(a[3]));//16个字节，sizeof内的表达式是不计算的，它只关注类型，a[3]的类型
                            //为int[4]，所以为16个字节。

数组名的意义：

1. sizeof(数组名)，这⾥的数组名表⽰整个数组，计算的是整个数组的⼤⼩。

2. &数组名，这⾥的数组名表⽰整个数组，取出的是整个数组的地址。

3. 除此之外所有的数组名都表⽰⾸元素的地址。

6、指针运算笔试题解析

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

运行结果为：

这个题目比较简单，就不再讲了。

6.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);//加1要跳过一个结构体。
	printf("%p\n", (unsigned long)p + 0x1);
	printf("%p\n", (unsigned int*)p + 0x1);
	return 0;
}

运行结果为:

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

运行结果为：

6.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]);
	return 0;
}

图解：

运行结果为：

6.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));
	printf("%d,%d", *(ptr1 - 1), *(ptr2 - 1));
	return 0;
}

运行结果为：

6.6、题⽬6

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

运行结果为：

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

图解：

运行结果为：

6.8、题目8

//X86环境下运行
#include<stdio.h>//指针加1，取决于指针的类型。它要跳过一个它本身类型大小的空间。
//整数加1，那就是加1
int main()
{
	int a[4] = { 1,2,3,4 };

	int* ptr1 = (int*)(&a + 1);

	int* ptr2 = (int*)((int)a + 1);

	printf("%#x,%#x", ptr1[-1], *ptr2);//使用#可以让程序打印16进制时，把0x也给打印出来。

	return 0;
}

图解：