学习目录
————————————————————————————————————————————————————————————————————————————————————————————————————————————————————————————————————————————————————————————————————————————
字符指针变量（常量字符串和 变量字符串）
常量字符串和变量字符串是在编程中常见的两种字符串类型，它们有以下区别：
- 值的不可变性：常量字符串的值是不可变的，一旦被定义，就不能修改。而变量字符串的值是可变的，可以随时修改。
常量字符串1：
const char* constantString = "Hello, World!";
在上述代码中，“Hello, World!” 是一个常量字符串，其值不可修改。变量字符串1：
char variableString[] = "Hello, World!";
在上述代码中，variableString 是一个变量字符串，其值可以修改。
存储方式：常量字符串通常存储在只读内存区域，而变量字符串通常存储在可读写的内存区域。—————————————————————————————————————————————————————————————————————————————————————
常量字符串2：
const char* constantString = "Hello, World!";
在上述代码中，“Hello, World!” 是一个常量字符串，它通常存储在只读内存区域。变量字符串2：
char variableString[] = "Hello, World!";
在上述代码中，variableString 是一个变量字符串，它通常存储在可读写的内存区域。
内存分配方式：常量字符串通常在编译时就被分配内存空间，而变量字符串通常在运行时动态分配内存空间。—————————————————————————————————————————————————————————————————————————————————————
常量字符串3：
const char* constantString = "Hello, World!";
在上述代码中，“Hello, World!” 是一个常量字符串，它在编译时就被分配了内存空间。变量字符串3：
char variableString[] = "Hello, World!";
在上述代码中，variableString 是一个变量字符串，它在运行时动态分配了内存空间。想了解更多，可以看看这个篇章哦，有图像举例
C语言指针——常量字符串和 变量字符串-CSDN博客
———————————————————————————————————————————————————————————————————————————————————————————————————————————————————————————————————————————————————————————————————————————
指针数组
指针数组的作用
指针数组和数组指针是C语言中常用的概念，它们分别有不同的作用和用法。
- 指针数组： 指针数组是一个数组，其中的每个元素都是指针类型。它可以用来存储多个指针，每个指针可以指向不同的数据类型或者相同的数据类型。指针数组的作用是方便地管理多个指针，可以通过遍历数组来访问每个指针所指向的数据。
int* ptrArray[5]; // 定义一个包含5个指针的指针数组
int a = 1, b = 2, c = 3;
ptrArray[0] = &a; // 第一个指针指向变量a
ptrArray[1] = &b; // 第二个指针指向变量b
ptrArray[2] = &c; // 第三个指针指向变量c
for (int i = 0; i < 3; i++) {
printf("%d\n", *ptrArray[i]); // 输出每个指针所指向的值
}——————————————————————————————————————————————————————————————————————————————————————
整形数组 存放整形的数组
字符数组 存放字符的数组
指针数组 存放字符的数组
指针数组是一个数组，其中的每个元素都是指针类型。简单来说，它是一个存储指针的数组。
定义一个指针数组的语法
<数据类型> *<数组名>[<数组大小>];其中，<数据类型>表示指针所指向的数据类型，<数组名>是数组的名称，<数组大小>表示数组的大小。
指针数组可以存储多个指针，每个指针可以指向不同的内存地址。这使得指针数组非常灵活，可以用于存储不同类型的数据或者不同对象的地址。
例如，定义一个指针数组来存储整型指针：
int *ptrArray[5];这个指针数组可以存储5个整型指针。每个元素都可以指向一个整型变量或者整型数组。
使用指针数组时，可以通过索引来访问和操作每个指针元素。例如，可以通过ptrArray来访问第一个指针元素，并通过*ptrArray来访问该指针所指向的值。
总结一下，指针数组是一个存储指针的数组，它提供了一种灵活的方式来存储和操作不同类型的指针
下面进行指针数组的举例（参考指针数组模拟二维数组）
指针篇章-（2）-（一级指针和二级指针之间的理解）-CSDN博客
———————————————————————————————————————————————————————————————————————————————————————————————————————————————————————————————————————————————————————————————————————————
数组指针
数组指针的作用
数组指针的作用主要有以下几个方面：
- 遍历数组：通过数组指针，可以使用指针算术运算来遍历数组中的元素，实现对数组的遍历操作。
- 传递数组给函数：通过将数组指针作为参数传递给函数，可以在函数内部对数组进行操作，而无需复制整个数组。
- 动态分配内存：通过数组指针，可以使用动态内存分配函数（如malloc）来动态创建数组，灵活地管理内存空间。
—————————————————————————————————————————————————————————————————————————————————————
数组指针变量是什么
数组指针是指向数组的指针变量。它可以用来表示数组的首地址，并可以通过指针的偏移来访问数组中的元素。定义数组指针的语法如下：
其中，数据类型表示数组中元素的类型，指针变量名是指针变量的名称，数组长度表示数组的长度。
根本的说
指针数组，是数组
数组指针是指针
数组指针是指向数组的指针，它可以指向数组的首地址。通过数组指针可以访问数组中的元素，可以进行指针运算来遍历数组。例如，int* ptr 表示一个指向 int 类型的数组的指针。
而数组指针变量是一个变量，它存储了一个数组指针的地址。它本身并不指向数组，而是指向一个指针，这个指针指向数组的首地址。通过数组指针变量可以间接地访问数组中的元素。例如，int* arrPtr[] 表示一个数组，其中的每个元素都是 int 类型的指针。
不加上括号则p和【】是一体的 加上了 则不是一体 [ ]的优先级更高
—————————————————————————————————————————————————————————————————————————————————————
数组指针示范1
这里取出的是整个数组的地址 ，但是他本身代表的的是数组首元素的地址
#define _CRT_SECURE_NO_WARNINGS 1
#include <stdio.h>
int main()
{
int arr[10] = { 0 };
int* pl = arr;
printf("%p\n", pl);
printf("%p\n", pl + 1);//所以+1 加上的是一个地址大小
int(*p2)[10] = &arr;//这里取出的是整个数组的地址 ，但是他本身代表的的是数组首元素的地址
printf("%p\n", p2);
printf("%p\n", p2 + 1);//所以+1 加上的是整个地址
return 0;
}
—————————————————————————————————————————————————————————————————————————————————————
数组指针语法格式
数据类型 (*指针变量名)[数组长度];这里注意要带括号
int arr[5] = {1, 2, 3, 4, 5};
int (*ptr)[5]; // 定义一个指向整型数组的指针变量
ptr = &arr; // 将指针指向数组的首地址—————————————————————————————————————————————————————————————————————————————————————
数组指针示范 2
#include <stdio.h>
int main() {
int arr[10] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
int (*p)[10] = &arr;
int i = 0;
for (i = 0; i < 10; i++) {
printf("%d ", (*p)[i]);
}
return 0;
}
在main函数中，首先定义了一个长度为10的整型数组arr，
并初始化了数组的元素。然后定义了一个指向数组的指针p，
并将其指向数组arr。接下来使用一个循环遍历数组arr，
通过指针p来访问数组元素，并使用printf函数将每个元素打印出来。—————————————————————————————————————————————————————————————————————————————————————
二维数组传参的本质
一维数组和二维数组
指针指向第一行的五个元素的数组
一次跳过一行
j是二维数组里面的一维数组的每个元素
二维数组传参可以写成数组也可以写成指针的形式
补充
这里详细介绍二维数组和一维数组以及指针的的关系，在指针5里面会进行详细介绍
这里可以先进行学习一下 这里主要是讲解的是数组名的代表的分别是什么
sizeof和strlen的详细万字解读-CSDN博客
——————————————————————————————————————————————————————————————————————————————————————
指针数组和数组指针二者的区别总结
-
数组指针（Array Pointer）： 数组指针是指向数组的指针变量。它可以用来访问数组中的元素。数组指针的语法格式如下：
数据类型 (*指针变量名)[数组长度]; 这里的数据类型表示数组中元素的类型，指针变量名是指向数组的指针变量的名称，数组长度表示数组的长度。例如，如果要定义一个指向整型数组的指针变量，可以使用以下语法： int (*ptr)[5]; 这样就定义了一个指向包含5个整型元素的数组的指针变量ptr。 -
指针数组（Array of Pointers）： 指针数组是一个数组，其中的每个元素都是指针。它可以存储多个指针值。指针数组的语法格式如下：
数据类型 *指针数组名[数组长度]; 这里的数据类型表示指针所指向的数据类型，指针数组名是指针数组的名称，数组长度表示数组的长度。例如，如果要定义一个包含3个整型指针的指针数组，可以使用以下语法： int *arr[3]; 这样就定义了一个包含3个整型指针的指针数组arr。
实例剖析
指针篇章-（冒泡排序详解）-CSDN博客
————————————————————————————————————————————————————————————————————————————————————————————————————————————————————————————————————————————————————————————————————————————
函数指针变量和函数指针数组
函数指针变量
函数指针变量的作用
函数指针变量是指向函数的指针，它可以用来存储函数的地址，并且可以通过该指针调用相应的函数。函数指针变量的作用主要有以下几个方面：
-
回调函数：函数指针变量可以作为参数传递给其他函数，从而实现回调函数的功能。当某个条件满足时，可以通过函数指针调用相应的回调函数，实现特定的功能。
-
动态选择函数：通过函数指针变量，可以在运行时根据不同的条件选择不同的函数执行。这样可以提高程序的灵活性和可扩展性。
-
函数的别名：函数指针变量可以作为函数的别名使用，可以简化代码，提高代码的可读性。
-
实现函数表：通过将多个函数的指针存储在一个数组或者结构体中，可以实现函数表。通过索引或者其他方式，可以方便地调用相应的函数。
——————————————————————————————————————————
函数指针变量语法格式
这里和指针数组
———————————————————————————————————————————
函数指针变量的定义和举例
函数指针是指向函数的指针变量。它可以用来存储函数的地址，从而可以通过指针调用函数。函数指针的定义方式如下：
返回类型 (*指针变量名)(参数列表);其中，返回值类型是函数的返回值类型，指针变量名是函数指针的名称，参数列表是函数的参数类型和个数。
下面是一个函数指针的示例：
例如，我们有一个函数 add，它接受两个整数参数并返回它们的和。我们可以声明一个函数指针 p 来指向该函数：
int add(int a, int b) {
return a + b;
}
int (*p)(int, int); // 声明一个函数指针变量p
p = add; // 将函数add的地址赋值给p
int result = p(3, 4); // 通过函数指针调用add函数
在上面的例子中，我们声明了一个返回类型为 int，参数列表为 (int, int) 的函数指针 p。然后，我们将函数 add 的地址赋值给了 p，最后通过 p 调用了 add 函数并将结果赋给了 result。
函数指针在实际应用中非常有用，可以用于实现回调函数、动态加载库中的函数等场景———————————————————————————————————————————
函数指针变量语法格式的讲解
数组指针->指针->指向数组的->存放的是数组的地址
&数组名是数组的地址
数组名是数组首元素的地址，两个地址的值是一样的!
对于首元素的理解不深入的 ，可以看一下这一篇文章
指针数组和数组指针（详细解释）-CSDN博客
https://blog.csdn.net/Jason_from_China/article/details/136581096
pf专门 用来存放地址 
按照函数指针的格式来进行书写，就变成函数指针
这里是语法是相互对应的
这里的括号是不能去掉的，虽然pf是变量名字，但是那个括号是不能去掉的
去掉*pf外面的括号的话
pf就变成了名字不再是代表指针函数数组
而是变成，表示一个函数的声明，该函数返回一个返回值类型的指针变量。
所以，这里的语法格式是不能改变的
所以，这样也是可以的
函数指针变量函数名的调用和函数指针调用的对比
函数名调用
拿一个数值进行接收，直接传参 
函数指针的调用
此时pf的*和（）可以写也可以不写
并且函数名本身就等于调用的函数，类似于重命名
最后打印接收的返回值
——————————————————————————————————————————————————————————————————————————————————————
补充知识
强制类型转化
作用
C语言中的强制类型转换是一种将一个数据类型转换为另一个数据类型的操作。它可以通过显式地指定要转换的数据类型来实现。强制类型转换可以用于以下几种情况：
-
改变变量的数据类型：当需要将一个变量的数据类型从一种类型转换为另一种类型时，可以使用强制类型转换。例如，将一个整数转换为浮点数，或者将一个字符转换为整数。
-
提升数据类型：当进行表达式计算时，如果参与计算的操作数具有不同的数据类型，C语言会自动进行隐式类型转换，将较低精度的操作数提升为较高精度的操作数。但是有时候我们需要手动进行提升，以确保计算结果的准确性。
-
缩小数据类型：有时候我们需要将一个较高精度的数据类型转换为较低精度的数据类型，这时候就需要使用强制类型转换。需要注意的是，缩小数据类型可能会导致数据丢失或溢出，因此需要谨慎使用。
强制类型转换的语法如下：
(目标类型) 表达式其中，目标类型是要转换成的数据类型，表达式是要进行转换的值或变量。
需要注意的是，强制类型转换可能会导致数据的精度丢失或溢出，因此在使用时需要谨慎考虑。此外，过度使用强制类型转换可能会导致代码可读性降低，建议在必要的情况下使用。
举例
C语言中的强制类型转换是一种将一个数据类型转换为另一个数据类型的操作。它可以通过使用强制类型转换运算符来实现，即将要转换的数据类型放在要转换的值或表达式前面，用括号括起来。
例如，将一个整数类型转换为浮点类型可以使用强制类型转换。下面是一个示例：
int num = 10; float result = (float)num;
在上面的示例中，我们将整数类型的变量num强制转换为浮点类型，并将结果赋给浮点类型的变量result。需要注意的是，强制类型转换可能会导致数据丢失或精度损失。因此，在进行强制类型转换时，需要谨慎考虑数据类型之间的兼容性和可能的副作用。
具体举例
函数的返回类型
强制类型转化的语法
——————————————————————————————————————————————————————————————————————————————————————
typedef
typedef类型重命名
这里一笔带过 ，在指针2里面讲的很清楚，结构体和结构体的重命名
结构体详解-CSDN博客https://blog.csdn.net/Jason_from_China/article/details/136477956指针篇章-（2）-CSDN博客https://blog.csdn.net/Jason_from_China/article/details/136408404
————————————————————————————————————————————————————————————————————————————————————————————————————————————————————————————————————————————————————————————————————————————
函数指针数组
函数指针数组的作用
函数指针数组是一个数组，其中的每个元素都是一个函数指针。函数指针是指向函数的指针变量，可以用来调用相应的函数。函数指针数组的作用是可以根据需要动态地选择并调用不同的函数。
函数指针数组的使用场景有很多，以下是一些常见的应用：
- 回调函数：函数指针数组可以用于实现回调机制，即在某个事件发生时，根据不同的情况选择并调用相应的回调函数。
- 状态机：函数指针数组可以用于实现状态机，即根据当前状态选择并调用相应的处理函数。
- 命令分发：函数指针数组可以用于实现命令分发，即根据接收到的命令选择并调用相应的处理函数。
- 策略模式：函数指针数组可以用于实现策略模式，即根据不同的策略选择并调用相应的处理函数。
总之，函数指针数组提供了一种灵活的方式来选择并调用不同的函数，可以根据具体需求动态地改变函数的行为。
——————————————————————————————————————————
函数指针数组的语法格式
函数指针数组是一个数组，其中的元素都是函数指针。函数指针是指向函数的指针变量，可以用来调用相应的函数。函数指针数组的语法格式如下：
返回值类型 (*指针数组名[数组大小])(参数列表);其中，返回值类型是函数的返回值类型，指针数组名是函数指针数组的名称，数组大小是指针数组中元素的个数，参数列表是函数的参数类型和个数。
举个例子，
如果我们有一个函数指针数组，其中包含两个元素，个元素都指向一个无返回值、无参数的函数，可以这样声明：
void (*funcPtrArray[2])();
这里，funcPtrArray是一个包含两个元素的函数指针数组，每个元素都是一个指向无返回值、无参数的函数的指针。使用函数指针数组时，可以通过索引来访问数组中的元素，并通过函数指针调用相应的函数。
——————————————————————————————————————————
函数指针数组语法格式的讲解
举例来说，我们可以定义一个函数指针数组，其中的元素指向不同的排序算法函数：
#include <stdio.h>
// 声明排序算法函数
void bubbleSort(int arr[], int size);
void selectionSort(int arr[], int size);
void insertionSort(int arr[], int size);
int main() {
// 定义函数指针数组并初始化
void (*sortFuncs[3])(int[], int) = {bubbleSort, selectionSort, insertionSort};
//函数指针 函数指针定义三个 ，然后是（数组和，整形类型的）
// 调用函数指针数组中的函数
int arr[] = {5, 2, 8, 1, 9};
int size = sizeof(arr) / sizeof(arr[0]);
for (int i = 0; i < 3; i++)
{
sortFuncs[i](arr, size);//这里主要是看这一段 这个代码是我随机从网上找的，主要是让你们看看这个语法格式的使用 ，下面会进行转移表，也就是计算器的使用版本2，就是采取函数指针数组的形势进行计算的
printf("排序结果：");
for (int j = 0; j < size; j++)
{
printf("%d ", arr[j]);
}
printf("\n");
}
return 0;
}
// 冒泡排序
void bubbleSort(int arr[], int size) {
// 排序逻辑...
}
// 选择排序
void selectionSort(int arr[], int size) {
// 排序逻辑...
}
// 插入排序
void insertionSort(int arr[], int size) {
// 排序逻辑...
}
——————————————————————————————————————————————————————————————————————————————————————
函数指针数组的实际使用（转移表（计算器））
这里会简单提一嘴，在指针4篇章还会进行详细的解释，指针4篇章会详细解释qsort函数的使用和构建模拟
计算器的模拟版本1
运算函数
主函数
计算器形成
但是之前的代码是有问题的，冗余性太强
#include<stdio.h>
// 函数原型声明
int add(int x, int y);
int subtract(int x, int y);
int multiply(int x, int y);
int divide(int x, int y);
int main() {
int input;
printf("请输入运算类型（1-加法，2-减法，3-乘法，4-除法，0-退出）：");
scanf("%d", &input);
while (input != 0) {
switch (input) {
case 1:
printf("请输入两个加数：");
int x, y;
scanf("%d %d", &x, &y);
printf("%d\n", add(x, y));
break;
case 2:
printf("请输入两个减数：");
scanf("%d %d", &x, &y);
printf("%d\n", subtract(x, y));
break;
case 3:
printf("请输入两个乘数：");
scanf("%d %d", &x, &y);
printf("%d\n", multiply(x, y));
break;
case 4:
printf("请输入两个数，其中第二个数为除数：");
scanf("%d %d", &x, &y);
if (y != 0) {
printf("%d\n", divide(x, y));
} else {
printf("除数不能为0。\n");
}
break;
default:
printf("输入错误，请输入正确的运算类型。\n");
break;
}
printf("是否继续？（0-否，其他值-是）：");
scanf("%d", &input);
}
printf("退出计算器。\n");
return 0;
}
// 函数定义
int add(int x, int y) {
return x + y;
}
int subtract(int x, int y) {
return x - y;
}
int multiply(int x, int y) {
return x * y;
}
int divide(int x, int y) {
return x / y;
}
这里ai解释一下 不过多赘述
这次计算机的目的是为了进行回调函数和函数指针数组的学习
这段C语言代码实现了一个简单的计算器，能够进行加法、减法、乘法和除法运算。下面是逐行解释：
1. `#include<stdio.h>`：这行代码包含了标准输入输出头文件`stdio.h`，它是C语言中用于输入输出函数的基础头文件。
2. 函数原型声明：这些是函数原型声明，指明了将要定义的四个函数`add`、`subtract`、`multiply`和`divide`的返回类型和参数类型。
3. `int main()`：这是主函数的定义，`main`是C程序的入口点。
4. `int input;`：这行代码定义了一个整数变量`input`，用于存储用户的选择。
5. `printf("请输入运算类型（1-加法，2-减法，3-乘法，4-除法，0-退出）：");`：这行代码打印出提示信息，要求用户输入运算类型。
6. `scanf("%d", &input);`：这行代码使用`scanf`函数从用户那里读取一个整数，并存储在变量`input`中。
7. `while (input != 0) {`：这是一个`while`循环，它会在用户输入0之前一直执行。
8. `switch (input)`：这是一个`switch`语句，它根据变量`input`的值来执行不同的代码块。
9. `case 1:`：这是一个`case`标签，当`input`等于1时，执行后面的代码块。
10. `printf("请输入两个加数：");`：这行代码打印出提示信息，要求用户输入两个加数。
11. `scanf("%d %d", &x, &y);`：这行代码使用`scanf`函数从用户那里读取两个整数，并存储在变量`x`和`y`中。
12. `printf("%d\n", add(x, y));`：这行代码调用`add`函数，并打印出返回的结果。
13. `break;`：这个关键字用于退出`switch`语句。
14. `case 2:`：这是一个`case`标签，当`input`等于2时，执行后面的代码块。
15. `printf("请输入两个减数：");`：这行代码打印出提示信息，要求用户输入两个减数。
16. `scanf("%d %d", &x, &y);`：这行代码使用`scanf`函数从用户那里读取两个整数，并存储在变量`x`和`y`中。
17. `printf("%d\n", subtract(x, y));`：这行代码调用`subtract`函数，并打印出返回的结果。
18. `break;`：这个关键字用于退出`switch`语句。
19. `case 3:`：这是一个`case`标签，当`input`等于3时，执行后面的代码块。
20. `printf("请输入两个乘数：");`：这行代码打印出提示信息，要求用户输入两个乘数。
21. `scanf("%d %d", &x, &y);`：这行代码使用`scanf`函数从用户那里读取两个整数，并存储在变量`x`和`y`中。
22. `printf("%d\n", multiply(x, y));`：这行代码调用`multiply`函数，并打印出返回的结果。
23. `break;`：这个关键字用于退出`switch`语句。
24. `case 4:`：这是一个`case`标签，当`input`等于4时，执行后面的代码块。
25. `printf("请输入两个数，其中第二个数为除数：");`：这行代码打印出提示信息，要求用户输入两个数，其中第二个数为除数。
26. `scanf("%d %d", &x, &y);`：这行代码使用`scanf`函数从用户那里读取两个整数，并存储在变量`x`和`y`中。
27. `if (y != 0) {`：这是一个`if`语句，它检查除数`y`是否不为0。
28. `printf("%d\n", divide(x, y));`：这行代码调用`———————————————————————————————————————————
计算器的模拟版本2（函数指针数组的使用）（回调函数）
简化
冗余
老的代码的问题就是
冗余
写死
不能完成不同的任务
函数调用的时候只需要知道地址就可以
calc计算器
这里也称之为转移表
#define _CRT_SECURE_NO_WARNINGS 1
#include<stdio.h>
int add(int x, int y)
{
return x + y;
}
int subtract(int x, int y)
{
return x - y;
}
int multiply(int x, int y)
{
return x * y;
}
int except(int x, int y)
{
return x / y;
}
void meun()
{
printf("**************************\n");
printf("***** 0 退出 ******\n");
printf("***** 1 加法 ******\n");
printf("***** 2 减法 ******\n");
printf("***** 3 乘法 ******\n");
printf("***** 4 除法 ******\n");
printf("**************************\n");
}
void cala(int* compute(int, int))
{
int x = 0; int y = 0;
int pf = 0;
scanf("%d %d", &x, &y);
pf = compute(x, y);
printf("%d ", pf);
}
int main()
{
meun();
int input = 0;
scanf("%d", &input);
switch (input)
{
case 0:
break;
case 1:
cala(add);
break;
case 2:
cala(subtract);
break;
case 3:
cala(subtract);
break;
case 4:
cala(except);
break;
default:
break;
}
}
这里 用ai 逐行解释一下 我不过多作图解释了：
1. `#define _CRT_SECURE_NO_WARNINGS 1`：这是一个预处理器指令，用于告诉编译器忽略与安全相关的警告
2. `#include<stdio.h>`：这是一个预处理器指令，用于包含标准输入输出头文件`stdio.h`，这是C语言中用于输入输出函数的基础头文件。
3. `int add(int x, int y)`：这是一个函数定义，`add`是一个函数名，它接受两个整数参数`x`和`y`，并返回它们的和。
4. `int subtract(int x, int y)`：这是另一个函数定义，`subtract`是一个函数名，它接受两个整数参数`x`和`y`，并返回它们的差。
5. `int multiply(int x, int y)`：这是另一个函数定义，`multiply`是一个函数名，它接受两个整数参数`x`和`y`，并返回它们的积。
6. `int except(int x, int y)`：这是另一个函数定义，`except`是一个函数名，它接受两个整数参数`x`和`y`，并返回它们的商。注意，这个函数没有进行除数是否为0的检查，这在实际使用中是不安全的。
7. `void meun()`：这是一个函数定义，`meun`是一个函数名，它没有返回值。这个函数的作用是打印出菜单供用户选择运算类型。
8. `void cala(int* compute(int, int))`：这是另一个函数定义，`cala`是一个函数名，它接受一个指向函数的指针作为参数。这个函数的作用是调用用户提供的运算函数，并打印出结果。
9. `int main()`：这是主函数的定义，`main`是一个特殊的关键字，表示程序的入口点。
10. `meun();`：这行代码调用`meun`函数，打印出菜单。
11. `int input = 0;`：这行代码定义了一个整数变量`input`并初始化为0，用于存储用户的选择。
12. `scanf("%d", &input);`：这行代码使用`scanf`函数从用户那里读取一个整数，并存储在变量`input`中。
13. `switch (input)`：这是一个`switch`语句，它根据变量`input`的值来执行不同的代码块。
14. `case 0:`：这是一个`case`标签，当`input`等于0时，执行后面的代码块。
15. `break;`：这个关键字用于退出`switch`语句。
16. `case 1:`：这是一个`case`标签，当`input`等于1时，执行后面的代码块。
17. `cala(add);`：这行代码调用`cala`函数，并传递`add`函数的地址作为参数。
18. `break;`：这个关键字用于退出`switch`语句。
19. `case 2:`：这是一个`case`标签，当`input`等于2时，执行后面的代码块。
20. `cala(subtract);`：这行代码调用`cala`函数，并传递`subtract`函数的地址作为参数。
21. `break;`：这个关键字用于退出`switch`语句。
22. `case 3:`：这是一个`case`标签，当`input`等于3时，执行后面的代码块。
23. `cala(subtract);`：这行代码调用`cala`函数，并传递`subtract`函数的地址作为参数。这里似乎是一个错误，因为`subtract`函数并不适合乘法操作。
24. `break;`：这个关键字用于退出`switch`语句。
25. `case 4:`：这是一个`case`标签，当`input`等于4时，执行后面的代码块。
26. `cala(except);`：这行代码调用`cala`函数，并传递`except`函数的地址作为参数。
27. `break;`：——————————————————————————————————————————
版本3（函数指针数组的使用）
计算机代码的简化
创建函数指针的数组
#define _CRT_SECURE_NO_WARNINGS 1
#define _CRT_SECURE_NO_WARNINGS 1
#include<stdio.h>
int add(int x, int y)
{
return x + y;
}
int subtract(int x, int y)
{
return x - y;
}
int multiply(int x, int y)
{
return x * y;
}
int except(int x, int y)
{
return x / y;
}
void meun()
{
printf("**************************\n");
printf("***** 0 退出 ******\n");
printf("***** 1 加法 ******\n");
printf("***** 2 减法 ******\n");
printf("***** 3 乘法 ******\n");
printf("***** 4 除法 ******\n");
printf("**************************\n");
}
int main()
{
int (*compute[5])(int, int) = { 0, add,subtract,multiply,except };
int input = 0;
do
{
meun();
printf("请选择：\n");
scanf("%d", &input);
printf("请输入：");
if (input>=1&& input<=4)
{
int x = 0; int y = 0; int zd = 0;
scanf("%d %d", &x, &y);
zd = (*compute[input])(x, y);
printf("%d\n", zd);
}
else if (input == 0)
{
printf("退出程序。");
break;
}
else
{
printf("输入错误。");
}
} while (input);
}
这里 用ai 逐行解释一下 我不过多作图解释了：
这段代码是C语言编写的一个简单计算器程序，下面是逐行解释：
1. `#define _CRT_SECURE_NO_WARNINGS 1`：这是一个预处理器指令，用于告诉编译器忽略与安全相关的警告，特别是在使用像`fgets`、`fopen`等函数时。这行代码应该只包含一次，重复定义可能会导致编译错误。
2. `#include<stdio.h>`：这是一个预处理器指令，用于包含标准输入输出头文件`stdio.h`，这是C语言中用于输入输出函数的基础头文件。
3. `int add(int x, int y)`：这是一个函数定义，`add`是一个函数名，它接受两个整数参数`x`和`y`，并返回它们的和。
4. `int subtract(int x, int y)`：这是另一个函数定义，`subtract`是一个函数名，它接受两个整数参数`x`和`y`，并返回它们的差。
5. `int multiply(int x, int y)`：这是另一个函数定义，`multiply`是一个函数名，它接受两个整数参数`x`和`y`，并返回它们的积。
6. `int except(int x, int y)`：这是另一个函数定义，`except`是一个函数名，它接受两个整数参数`x`和`y`，并返回它们的商。注意，这个函数没有进行除数是否为0的检查，这在实际使用中是不安全的。
7. `void meun()`：这是一个函数定义，`meun`是一个函数名，它没有返回值。这个函数的作用是打印出菜单供用户选择运算类型。
8. `int main()`：这是主函数的定义，`main`是一个特殊的关键字，表示程序的入口点。
9. `int (*compute[5])(int, int) = { 0, add,subtract,multiply,except }`：这行代码定义了一个函数指针数组`compute`，长度为5。每个元素指向一个算术运算函数。数组的第一个元素被初始化为`0`，这通常用于指针数组的终止标志。
10. `int input = 0;`：这行代码定义了一个整数变量`input`并初始化为0，用于存储用户的选择。
11. `do`：这是一个循环开始关键字，表示开始一个`do-while`循环。
12. `meun();`：这行代码调用`meun`函数，打印出菜单。
13. `printf("请选择：\n");`：这行代码打印出提示信息“请选择：”。
14. `scanf("%d", &input);`：这行代码使用`scanf`函数从用户那里读取一个整数，并存储在变量`input`中。
15. `printf("请输入：");`：这行代码打印出提示信息“请输入：”。
16. `if (input>=1&& input<=4)`：这是一个条件判断，检查用户输入是否在1到4之间，包括1和4。
17. `{ int x = 0; int y = 0; int zd = 0;`：这个大括号开始了一个代码块，用于执行当用户输入在1到4之间时的操作。
18. `scanf("%d %d", &x, &y);`：这行代码使用`scanf`函数从用户那里读取两个整数，并存储在变量`x`和`y`中。
19. `zd = (*compute[input])(x, y);`：这行代码调用相应的运算函数，并将结果存储在变量`zd`中。
20. `printf("%d\n", zd);`：这行代码打印出计算结果。
21. `}`：这个大括号结束了上面的代码块。
22. `else if (input == 0)`：这是另一个条件判断，检查用户输入是否为0。
23. `{ printf("退出程序。");`：这个代码块用于执行当用户输入为0时的操作，打印出提示信息。
24. `break;`：这个关键字用于退出循环。
25. `}`：这个大括号结束了上面的条件判断。
26. `else`：这是另一个条件判断，用于处理用户输入不在1到4之间——————————————————————————————————————————
计算器代码总结
#define _CRT_SECURE_NO_WARNINGS 1
#include<stdio.h>
//菜单
void meun()
{
printf("**************************\n");
printf("***** 0 退出 ******\n");
printf("***** 1 加法 ******\n");
printf("***** 2 减法 ******\n");
printf("***** 3 乘法 ******\n");
printf("***** 4 除法 ******\n");
printf("**************************\n");
}
// 函数定义
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 dive(int x, int y)
{
return x / y;
}
//函数指针数组的使用
void Function_pointers()
{
int(*compute[5])(int, int) = { 0,add,sub,mul,dive };
int input = 0; int x = 0; int y = 0;
do
{
if (input > 0 && input <= 4)
{
meun();
printf("请输入>\n");
scanf("%d", &input);
printf("请输入计算数值>\n");
scanf("%d %d", &x, &y);
int outcome = (*compute[input])(x, y);
printf("结果是：%d\n", outcome);
}
else if (input == 0)
{
printf("退出");
break;
}
else
{
printf("输入错误。");
}
} while (input);
}
//回调函数的使用
void invoke(int*ps(int, int))
{
int x = 0; int y = 0;
printf("请输入计算数值>\n");
scanf("%d %d", &x, &y);
int outcome = (*ps)(x, y);
printf("结果是：%d\n", outcome);
}
void Callback()
{
int input = 0;
do
{
meun();
printf("请输入>\n");
scanf("%d", &input);
switch (input)
{
case 0:
break;
case 1:
invoke(add);
break;
case 2:
invoke(sub);
break;
case 3:
invoke(mul);
break;
case 4:
invoke(dive);
break;
default:
printf("输入错误。");
break;
}
} while (input);
}
//正常计算函数
void count()
{
int input = 0;
do
{
int x = 0; int y = 0;
meun();
printf("请输入>\n");
scanf("%d", &input);
int outcomt = 0;
switch (input)
{
case 0:
printf("退出");
break;
case 1:
printf("请输入计算数值>\n");
scanf("%d %d", &x, &y);
outcomt = add(x, y);
printf("结果是：%d\n", outcomt);
break;
case 2:
printf("请输入计算数值>\n");
scanf("%d %d", &x, &y);
outcomt = sub(x, y);
printf("结果是：%d\n", outcomt);
break;
case 3:
printf("请输入计算数值>\n");
scanf("%d %d", &x, &y);
outcomt = mul(x, y);
printf("结果是：%d\n", outcomt);
break;
case 4:
printf("请输入计算数值>\n");
scanf("%d %d", &x, &y);
outcomt = dive(x, y);
printf("结果是：%d\n", outcomt);
break;
default:
printf("输入错误。");
break;
}
} while (input);
}
//主函数
int main()
{
//printf("函数指针数组的使用>\n");
//Function_pointers();
//printf("回调函数的使用>\n");
//Callback();
printf("正常函数的使用>\n");
count();
}————————————————————————————————————————————————————————————————————————————————————————————————————————————————————————————————————————————————————————————————————————————
函数指针变量和函数指针数组区别
函数指针变量和函数指针数组是两种不同的概念。
-
函数指针变量是指向函数的指针，它可以存储一个函数的地址。通过函数指针变量，我们可以直接调用该函数。函数指针变量的声明方式为：
返回类型 (*指针变量名)(参数列表)。例如，int (*funcPtr)(int, int)表示一个返回类型为int，接受两个int类型参数的函数指针变量。 -
函数指针数组是一个数组，其中的每个元素都是一个函数指针。每个函数指针可以指向不同的函数。函数指针数组的声明方式为：
返回类型 (*数组名[数组长度])(参数列表)。例如，int (*funcPtrArray)(int, int)表示一个包含5个元素的函数指针数组，每个元素都是一个返回类型为int，接受两个int类型参数的函数指针。
总结一下：
- 函数指针变量可以指向一个函数，通过该指针变量可以直接调用该函数。
- 函数指针数组是一个数组，其中的每个元素都是一个函数指针，每个函数指针可以指向不同的函数。
