目录
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;
}图解：
运行结果为：
到这里，指针的内容就暂时结束了。
如果有问题，欢迎到评论区进行交流或者私信。
