一、回调函数
1.1、回调函数定义
回调函数就是一个通过函数指针调用的函数。
如果把函数的指针(地址)作为参数传递给另一个函数,当这个指针被用来调用其所指向的函数时,被调用的函数就是回调函数
例如:使用函数指针实现计算器:
首先我们需要定义四个运算函数
Add(int x, int y)
:返回两个整数的和。Sub(int x, int y)
:返回两个整数的差。Mul(int x, int y)
:返回两个整数的乘积。Div(int x, int y)
:返回两个整数的商。然后需要构造辅助函数来让用户选择:
menu()
:打印出计算器的菜单选项。calc(int (*pf)(int, int))
:接受一个函数指针作为参数,然后提示用户输入两个操作数,并调用该函数指针指向的函数来计算结果,最后打印结果。最后来写主函数:
- 定义一个整型变量
input
,用于存储用户的选择。- 使用
do-while
循环来反复显示菜单并接受用户输入。- 调用
menu()
函数显示菜单。- 提示用户输入选择,并读取到
input
变量中。- 使用
switch
语句根据用户的选择调用不同的函数:
- 如果用户选择
1
,则调用calc(Add)
进行加法运算。- 如果用户选择
2
,则调用calc(Sub)
进行减法运算。- 如果用户选择
3
,则调用calc(Mul)
进行乘法运算。- 如果用户选择
4
,则调用calc(Div)
进行除法运算。- 如果用户选择
0
,则打印退出信息并退出循环。- 如果用户输入了其他值,则打印选择错误的信息。
- 当
input
为0时,do-while
循环结束。
代码如下:
//计算器
#include <stdio.h>
int Add(int x, int y)
{
return x + y;
}
int Sub(int x, int y)
{
return x - y;
}
int Mul(int x, int y)
{
return x * y;
}
int Div(int x, int y)
{
return x / y;
}
void menu()
{
printf("***************************\n");
printf("**** 1. add 2. sub ****\n");
printf("**** 3. mul 4. div ****\n");
printf("**** 0. exit ****\n");
printf("***************************\n");
}
void calc(int (*pf)(int, int))
{
int x = 0;
int y = 0;
int z = 0;
printf("请输入两个操作数:");
scanf("%d %d", &x, &y);
z = pf(x, y);
printf("%d\n", z);
}
int main()
{
int input = 0;
do
{
menu();
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;
}
二、qsort函数的应用
2.1、使用qsort函数排序整型数据
#include <stdio.h>
//qsort函数的使用者得实现一个比较函数
int int_cmp(const void* p1, const void* p2)
{
return (*(int*)p1 - *(int*)p2);
}
//上述的代码相当于:
//int cmp_int(const void* p1, const void* p2)
//{
// if (*(int*)p1 > *(int*)p2)
// return 1;
// else if (*(int*)p1 == *(int*)p2)
// return 0;
// else
// return -1;
//}
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;
}
qsort
函数的参数如下:
- 第一个参数是要排序的数组。
- 第二个参数是数组中的元素个数。
- 第三个参数是每个元素的大小(以字节为单位)。
- 第四个参数是比较函数。
2.2、使用qsort函数排序结构数据
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
struct Stu
{
char name[20];
int age;
};
int cmp_stu_by_name(const void* p1, const void* p2)
{
return strcmp(((struct Stu*)p1)->name, ((struct Stu*)p2)->name);
}
int cmp_stu_by_age(const void* p1, const void* p2)
{
return ((struct Stu*)p1)->age-((struct Stu*)p2)->age;
}
void test1()
{
struct Stu arr[3] = { {"zhangsan", 20},{"lisi", 35},{"wangwu", 18}};
int sz = sizeof(arr) / sizeof(arr[0]);
qsort(arr, sz, sizeof(arr[0]), cmp_stu_by_name);
}
void test2()
{
struct Stu arr[3] = { {"zhangsan", 20},{"lisi", 35},{"wangwu", 18} };
int sz = sizeof(arr) / sizeof(arr[0]);
qsort(arr, sz, sizeof(arr[0]), cmp_stu_by_age);
}
int main()
{
test1();
test2();
return 0;
}
三、sizeof和strlen的对比
3.1、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;
}
代码结果如下:
3.2、strlen
strlen是库函数,需要包含头文件string.h,它是求字符串长度的,统计的是\0之前字符的个数,如果没有\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(arr1));
return 0;
}
这里需要注意的是:
strlen(arr1)
的行为是未定义的,可能导致程序崩溃或输出不确定的值。
四、数组和指针
4.1、一维数组
#include <stdio.h>
int main()
{
int a[] = { 1,2,3,4 };//数组有几个元素?
printf("%zd\n", sizeof(a));//16 -- sizeof(数组名)的场景
printf("%zd\n", sizeof(a + 0));//a是首元素的地址-类型是int*, a+0 还是首元素的地址,是地址大小就是4/8
printf("%zd\n", sizeof(*a));//a是首元素的地址,*a就是首元素,大小就是4个字节
//*a == a[0] == *(a+0)
printf("%zd\n", sizeof(a + 1));//a是首元素的地址,类型是int*,a+1跳过1个整型,a+1就是第二个元素的地址,4/8
printf("%zd\n", sizeof(a[1]));//a[1]就是第二个元素,大小4个字节
printf("%zd\n", sizeof(&a));//&a是数组的地址,数组的地址也是地址,是地址大小就是4/8个字节
printf("%zd\n", sizeof(*&a));//1. *& 互相抵消了,sizeof(*&a) = sizeof(a) -16
//2. &a 是数组的地址,类型是int(*)[4],对数组指针解引用访问的是数组, 计算的是数组的大小 -16
//
printf("%zd\n", sizeof(&a + 1));//&a+1是跳过整个数组后的那个位置的地址,是地址就是4/8个字节
printf("%zd\n", sizeof(&a[0])); //首元素的地址,大小4/8个字节
printf("%zd\n", sizeof(&a[0] + 1));//&a[0] + 1 -- 数组第二个元素的地址,大小是4/8个字节
return 0;
}
4.2、字符数组
(1)、
#include <stdio.h>
int main()
{
char arr[] = { 'a','b','c','d','e','f' };
printf("%d\n", sizeof(arr));//数组名单独放在sizeof内部了,计算的是数组的大小,单位是字节-6
printf("%d\n", sizeof(arr + 0));//arr是数组名表示首元素的地址,arr+0还是首元素的地址,是地址就是4/8个字节
printf("%d\n", sizeof(*arr));//arr是首元素的地址,*arr就是首元素,大小就是1个字节
//*arr -- arr[0] - *(arr+0)
printf("%d\n", sizeof(arr[1]));//arr[1] 是第二个元素,大小也是1个字节
printf("%d\n", sizeof(&arr));//&arr 是数组地址,数组的地址也是地址,大小是4/8个字节
//&arr -- char (*)[6]
printf("%d\n", sizeof(&arr + 1));//&arr+1, 跳过整个数组,指向了数组后边的空间,4/8个字节
printf("%d\n", sizeof(&arr[0] + 1));//第二个元素的地址,是地址就是4/8字节
return 0;
}
(2)、
#include <string.h>
#include <stdio.h>
int main()
{
char arr[] = { 'a','b','c','d','e','f' };
printf("%d\n", strlen(arr));//arr是首元素的地址,数组中没有\0,就会导致越界访问,结果就是随机的
printf("%d\n", strlen(arr + 0));//arr+0是数组首元素的地址,数组中没有\0,就会导致越界访问,结果就是随机的
printf("%d\n", strlen(*arr));//arr是首元素的地址,*arr是首元素,就是'a','a'的ascii码值是97
//就相当于把97作为地址传递给了strlen,strlen得到的就是野指针, 代码是有问题的
printf("%d\n", strlen(arr[1]));//arr[1]--'b'--98,传给strlen函数也是错误的
printf("%d\n", strlen(&arr));//&arr是数组的地址,起始位置是数组的第一个元素的位置,随机值 x
printf("%d\n", strlen(&arr + 1));//随机值 x-6
printf("%d\n", strlen(&arr[0] + 1));//从第2个元素开始向后统计的,得到的也是随机值 x-1
return 0;
}
(3)、
int main()
{
char arr[] = "abcdef";
printf("%d\n", sizeof(arr));//arr是数组名,单独放在sizeof内部,计算的是数组总大小,是7个字节
printf("%d\n", sizeof(arr + 0));//arr表示数组首元素的地址,arr+0还是首元素的地址,是地址就是4/8
printf("%d\n", sizeof(*arr));//arr表示数组首元素的地址,*arr就是首元素,大小是1字节
printf("%d\n", sizeof(arr[1]));//arr[1]是第二个元素,大小1个字节
printf("%d\n", sizeof(&arr));//&arr是数组的地址,是地址就是4/8
printf("%d\n", sizeof(&arr + 1));//&arr是数组的地址,+1跳过整个数组,还是地址,是地址就是4/8个字节
printf("%d\n", sizeof(&arr[0] + 1));//&arr[0] + 1是第二个元素的地址,大小是4/8个字节
return 0;
}
(4)、
#include <string.h>
int main()
{
char arr[] = "abcdef";
printf("%d\n", strlen(arr));//6
printf("%d\n", strlen(arr + 0));//arr首元素的地址,arr+0还是首元素的地址,向后在\0之前有6个字符
//printf("%d\n", strlen(*arr));//'a'-97, 出错
//printf("%d\n", strlen(arr[1]));//'b'-98, 出错
printf("%d\n", strlen(&arr));//&arr是数组的地址,也是从数组第一个元素开始向后找,6
//&arr -- char (*)[7]
//size_t strlen(const char* s);
printf("%d\n", strlen(&arr + 1));//随机值
printf("%d\n", strlen(&arr[0] + 1));//5
return 0;
}
4.3、二维数组
int main()
{
int a[3][4] = { 0 };
printf("%d\n", sizeof(a));//a是数组名,单独放在sizeof内部,计算的是数组的大小,单位是字节 - 48 = 3*4*sizeof(int)
printf("%d\n", sizeof(a[0][0]));//a[0][0] 是第一行第一个元素,大小4个字节
printf("%d\n", sizeof(a[0]));//a[0]第一行的数组名,数组名单独放在sizeof内部了,计算的是数组的总大小 16 个字节
printf("%d\n", sizeof(a[0] + 1));//a[0]第一行的数组名,但是a[0]并没有单独放在sizeof内部,所以这里的数组名a[0]就是
//数组首元素的地址,就是&a[0][0],+1后是a[0][1]的地址,大小是4/8个字节
printf("%d\n", sizeof(*(a[0] + 1)));//*(a[0] + 1)表示第一行第二个元素,大小就是4
printf("%d\n", sizeof(a + 1));//a作为数组名并没有单独放在sizeof内部,a表示数组首元素的地址,是二维数组首元素的地址,也就是
//第一行的地址,a+1,跳过一行,指向了第二行,a+1是第二行的地址,a+1是数组指针,是地址大小就是4/8个字节
printf("%d\n", sizeof(*(a + 1)));//1.a+1是第二行的地址,*(a+1)就是第二行,计算的是第二行的大小 - 16
//2. *(a + 1) == a[1], a[1]是第二行的数组名,sizeof(*(a + 1))就相当于sizeof(a[1]),意思是把第二行的数组名单独放在
//sizeof内部,计算的是第二行的大小
printf("%d\n", sizeof(&a[0] + 1));//a[0]是第一行的数组名,&a[0]取出的就是数组的地址,就是第一行的地址
//&a[0]+1 就是第二行的地址,是地址大小就是4/8个字节
printf("%d\n", sizeof(*(&a[0] + 1)));//*(&a[0] + 1)意思是对第二行的地址解引用,访问的就是第二行,大小是16字节
printf("%d\n", sizeof(*a));//a作为数组名并没有单独放在sizeof内部,a表示数组首元素的地址,是二维数组首元素的地址,也就是
//第一行的地址,*a就是第一行,计算的就是第一行的大小,16字节
//*a == *(a+0) == a[0]
printf("%d\n", sizeof(a[3]));//a[3]无需真实存在,仅仅通过类型的推断就能算出长度
//a[3]是第四行的数组名,单独放在sizeof内部,计算的是第四行的大小,16个字节
//sizeof(int);//4
//sizeof(3 + 5);//4
return 0;
}