C 语言语法深入解析与实践指南

C 语言基础语法

变量与数据类型

1. 基本数据类型
   • 整型：C 语言提供了多种整型数据类型，以适应不同的数值范围和存储需求。例如，int 类型通常用于表示一般整数，其大小在不同系统上可能有所不同，但通常为 2 字节或 4 字节。以下是一个简单的 int 变量声明和赋值的示例：

#include <stdio.h>
int main() {
    int num = 10;
    printf("The value of num is: %d\n", num);
    return 0;
}

在上述代码中，我们声明了一个 int 类型的变量 num 并初始化为 10，然后使用 printf 函数输出其值。

• 字符型：char 类型用于表示单个字符。在 C 语言中，字符实际上是以其对应的 ASCII 码值存储的。例如：

#include <stdio.h>
int main() {
    char ch = 'A';
    printf("The character is: %c\n", ch);
    return 0;
}

这里声明了一个 char 类型的变量 ch 并初始化为字符 'A'，通过 printf 函数的 %c 格式说明符输出该字符。

• 浮点型：分为单精度 float 和双精度 double。float 通常占用 4 字节，double 通常占用 8 字节，double 能表示的数值范围更大且精度更高。以下是一个 float 类型变量的示例：

#include <stdio.h>
int main() {
    float f_num = 3.14f;
    printf("The float value is: %f\n", f_num);
    return 0;
}

注意，在给 float 类型变量赋值时，需要在数值后加上 f 或 F，以明确表示这是一个 float 类型的常量。

2. 变量声明与定义
   • 声明：变量声明向编译器告知变量的类型和名称，但并不为其分配内存空间。例如 extern int num; 这种声明方式，表示 num 是一个在其他地方定义的 int 类型变量。
   • 定义：变量定义不仅声明了变量，还为其分配了内存空间。例如 int num = 10; 这既是变量 num 的定义，同时进行了初始化。

运算符

1. 算术运算符
   • 基本算术运算符：包括加 +、减 -、乘 *、除 / 和取模 %。取模运算符只能用于整数运算，它返回除法的余数。以下是一个使用算术运算符的示例：

#include <stdio.h>
int main() {
    int a = 10, b = 3;
    printf("a + b = %d\n", a + b);
    printf("a - b = %d\n", a - b);
    printf("a * b = %d\n", a * b);
    printf("a / b = %d\n", a / b);
    printf("a %% b = %d\n", a % b);
    return 0;
}

在这段代码中，对 a 和 b 进行了各种算术运算，并通过 printf 函数输出结果。注意，在 printf 中输出 % 字符时，需要使用 %%。

• 自增自减运算符：++ 为自增运算符，-- 为自减运算符。它们有前置和后置两种形式。前置形式（如 ++a）先对变量进行加 1 或减 1 操作，然后再使用变量的值；后置形式（如 a++）先使用变量的值，然后再对变量进行加 1 或减 1 操作。例如：

#include <stdio.h>
int main() {
    int a = 5;
    int b = ++a;
    printf("b (++a) = %d\n", b);
    int c = a++;
    printf("c (a++) = %d\n", c);
    printf("a after a++ = %d\n", a);
    return 0;
}

在这个例子中，b = ++a 先将 a 加 1 变为 6，然后 b 赋值为 6；c = a++ 先将 a 的值 6 赋给 c，然后 a 再加 1 变为 7。

2. 关系运算符 关系运算符用于比较两个值，包括大于 >、小于 <、大于等于 >=、小于等于 <=、等于 == 和不等于 !=。它们返回一个整数，0 表示假，非 0 表示真。以下是一个使用关系运算符的示例：

#include <stdio.h>
int main() {
    int a = 10, b = 5;
    printf("a > b is %d\n", a > b);
    printf("a < b is %d\n", a < b);
    printf("a >= b is %d\n", a >= b);
    printf("a <= b is %d\n", a <= b);
    printf("a == b is %d\n", a == b);
    printf("a!= b is %d\n", a!= b);
    return 0;
}

此代码比较了 a 和 b 的大小关系，并输出相应的比较结果。

3. 逻辑运算符 逻辑运算符用于组合多个关系表达式，包括逻辑与 &&、逻辑或 || 和逻辑非 !。逻辑与 && 只有当两个操作数都为真时才返回真；逻辑或 || 只要有一个操作数为真就返回真；逻辑非 ! 用于对操作数取反。例如：

#include <stdio.h>
int main() {
    int a = 10, b = 5, c = 20;
    printf("(a > b) && (a < c) is %d\n", (a > b) && (a < c));
    printf("(a > b) || (a > c) is %d\n", (a > b) || (a > c));
    printf("!(a > b) is %d\n",!(a > b));
    return 0;
}

在这个例子中，通过逻辑运算符组合了多个关系表达式，并输出结果。注意逻辑运算符具有短路特性，例如在 (a > b) && (a < c) 中，如果 (a > b) 为假，那么 (a < c) 就不会再计算，因为整个逻辑与表达式已经为假。

4. 赋值运算符 最基本的赋值运算符是 =，用于将右侧的值赋给左侧的变量。除此之外，还有复合赋值运算符，如 +=、-=、*=、/=、%= 等。例如：

#include <stdio.h>
int main() {
    int a = 5;
    a += 3; // 等价于 a = a + 3;
    printf("a after a += 3 is %d\n", a);
    a *= 2; // 等价于 a = a * 2;
    printf("a after a *= 2 is %d\n", a);
    return 0;
}

在这个代码中，使用了复合赋值运算符对变量 a 进行操作，使代码更加简洁。

控制结构

条件语句

1. if - else 语句 if - else 语句根据条件判断的结果执行不同的代码块。基本形式如下：

if (condition) {
    // 条件为真时执行的代码块
} else {
    // 条件为假时执行的代码块
}

例如，判断一个数是否为正数：

#include <stdio.h>
int main() {
    int num = 10;
    if (num > 0) {
        printf("%d is a positive number.\n", num);
    } else {
        printf("%d is not a positive number.\n", num);
    }
    return 0;
}

如果 num 大于 0，就输出该数是正数；否则输出该数不是正数。if - else 语句还可以进行嵌套，以处理更复杂的条件判断：

#include <stdio.h>
int main() {
    int num = 10;
    if (num > 0) {
        if (num % 2 == 0) {
            printf("%d is a positive even number.\n", num);
        } else {
            printf("%d is a positive odd number.\n", num);
        }
    } else {
        printf("%d is not a positive number.\n", num);
    }
    return 0;
}

在这个嵌套的 if - else 语句中，先判断 num 是否为正数，若是正数再进一步判断是否为偶数。

2. switch - case 语句 switch - case 语句用于多分支选择，它根据一个表达式的值来选择执行不同的分支。基本形式如下：

switch (expression) {
    case constant1:
        // 当 expression 的值等于 constant1 时执行的代码
        break;
    case constant2:
        // 当 expression 的值等于 constant2 时执行的代码
        break;
    default:
        // 当 expression 的值与所有 case 常量都不相等时执行的代码
        break;
}

例如，根据输入的数字输出对应的星期几：

#include <stdio.h>
int main() {
    int day;
    printf("Enter a number between 1 and 7: ");
    scanf("%d", &day);
    switch (day) {
        case 1:
            printf("Monday\n");
            break;
        case 2:
            printf("Tuesday\n");
            break;
        case 3:
            printf("Wednesday\n");
            break;
        case 4:
            printf("Thursday\n");
            break;
        case 5:
            printf("Friday\n");
            break;
        case 6:
            printf("Saturday\n");
            break;
        case 7:
            printf("Sunday\n");
            break;
        default:
            printf("Invalid input\n");
            break;
    }
    return 0;
}

在这个例子中，switch 语句根据用户输入的数字 day，选择相应的 case 分支执行。break 语句用于跳出 switch 语句，避免继续执行下一个 case 分支。如果 day 的值与所有 case 常量都不相等，则执行 default 分支。

循环语句

1. for 循环 for 循环是一种常用的循环结构，适用于已知循环次数的情况。其基本形式为：

for (initialization; condition; increment) {
    // 循环体代码
}

例如，计算 1 到 10 的累加和：

#include <stdio.h>
int main() {
    int sum = 0;
    for (int i = 1; i <= 10; i++) {
        sum += i;
    }
    printf("The sum from 1 to 10 is: %d\n", sum);
    return 0;
}

在这个 for 循环中，i = 1 是初始化部分，i <= 10 是循环条件，i++ 是每次循环结束后执行的增量操作。循环体 sum += i 用于计算累加和。

2. while 循环 while 循环先判断条件，只要条件为真就执行循环体。基本形式为：

while (condition) {
    // 循环体代码
}

例如，计算输入数字的阶乘：

#include <stdio.h>
int main() {
    int num, factorial = 1;
    printf("Enter a number: ");
    scanf("%d", &num);
    int i = 1;
    while (i <= num) {
        factorial *= i;
        i++;
    }
    printf("The factorial of %d is: %d\n", num, factorial);
    return 0;
}

在这个 while 循环中，i <= num 是循环条件，循环体 factorial *= i 和 i++ 分别用于计算阶乘和增加循环变量的值。

3. do - while 循环 do - while 循环先执行一次循环体，然后再判断条件。基本形式为：

do {
    // 循环体代码
} while (condition);

例如，实现一个简单的猜数字游戏，用户猜错时继续提示猜测：

#include <stdio.h>
#include <stdlib.h>
#include <time.h>
int main() {
    srand(time(0));
    int target = rand() % 100 + 1;
    int guess;
    do {
        printf("Guess a number between 1 and 100: ");
        scanf("%d", &guess);
        if (guess > target) {
            printf("Too high!\n");
        } else if (guess < target) {
            printf("Too low!\n");
        }
    } while (guess!= target);
    printf("Congratulations! You guessed the number.\n");
    return 0;
}

在这个 do - while 循环中，先让用户输入猜测的数字，然后根据猜测结果给出提示，只要猜测不正确就继续循环，直到猜对为止。

函数

函数定义与调用

1. 函数定义 函数是一段完成特定任务的代码块。其定义形式如下：

return_type function_name(parameter_list) {
    // 函数体代码
    return return_value;
}

例如，定义一个函数计算两个整数的和：

#include <stdio.h>
int add(int a, int b) {
    int sum = a + b;
    return sum;
}
int main() {
    int num1 = 5, num2 = 3;
    int result = add(num1, num2);
    printf("The sum of %d and %d is: %d\n", num1, num2, result);
    return 0;
}

在这个例子中，add 函数接受两个 int 类型的参数 a 和 b，计算它们的和并返回。main 函数中调用 add 函数，并输出计算结果。

2. 函数调用 函数调用就是执行函数的代码。当调用函数时，实参的值会传递给形参。函数调用可以出现在表达式中，也可以作为独立的语句。例如上述代码中 int result = add(num1, num2); 就是函数调用作为表达式，将 add 函数的返回值赋给 result 变量。

函数参数与返回值

1. 函数参数 函数参数分为形参和实参。形参是在函数定义时声明的变量，实参是在函数调用时传递给函数的值。C 语言中函数参数传递方式主要是值传递，即实参的值被复制给形参，形参的改变不会影响实参。例如：

#include <stdio.h>
void change_value(int num) {
    num = num + 10;
}
int main() {
    int a = 5;
    change_value(a);
    printf("The value of a is: %d\n", a);
    return 0;
}

在这个例子中，change_value 函数的形参 num 接收了 a 的值，在函数内部对 num 进行加 10 操作，但这并不会改变 a 的值，所以最终输出 a 的值仍然是 5。

2. 函数返回值 函数通过 return 语句返回一个值。返回值的类型必须与函数定义的返回类型一致。如果函数不需要返回值，可以将返回类型定义为 void。例如：

#include <stdio.h>
void print_message() {
    printf("This is a message from the function.\n");
}
int main() {
    print_message();
    return 0;
}

在这个例子中，print_message 函数的返回类型是 void，它不返回值，只是在函数内部输出一条消息。

函数的递归

递归是指函数在执行过程中调用自身的一种编程技巧。例如，计算阶乘可以用递归方式实现：

#include <stdio.h>
int factorial(int n) {
    if (n == 0 || n == 1) {
        return 1;
    } else {
        return n * factorial(n - 1);
    }
}
int main() {
    int num = 5;
    int result = factorial(num);
    printf("The factorial of %d is: %d\n", num, result);
    return 0;
}

在 factorial 函数中，当 n 为 0 或 1 时，直接返回 1，这是递归的终止条件。否则，通过调用 factorial(n - 1) 来递归计算阶乘。递归调用会不断地创建函数的新实例，直到满足终止条件，然后逐步返回计算结果。

数组

一维数组

1. 数组定义与初始化 一维数组是相同类型元素的有序集合。定义数组的语法为：

data_type array_name[size];

例如，定义一个包含 5 个整数的数组：

int numbers[5];

数组可以在定义时进行初始化，例如：

int numbers[5] = {1, 2, 3, 4, 5};

也可以省略数组大小，让编译器根据初始化的值来推断数组的大小：

int numbers[] = {1, 2, 3, 4, 5};

2. 数组元素访问 数组元素通过下标来访问，下标从 0 开始。例如，访问 numbers 数组的第一个元素可以使用 numbers[0]。以下是一个遍历数组并输出所有元素的示例：

#include <stdio.h>
int main() {
    int numbers[] = {1, 2, 3, 4, 5};
    for (int i = 0; i < 5; i++) {
        printf("Element at index %d is: %d\n", i, numbers[i]);
    }
    return 0;
}

在这个 for 循环中，通过 i 作为下标来依次访问数组 numbers 的每个元素并输出。

二维数组

1. 二维数组定义与初始化 二维数组可以看作是数组的数组，常用于表示矩阵等二维结构。定义二维数组的语法为：

data_type array_name[row_size][col_size];

例如，定义一个 3 行 4 列的二维整数数组：

int matrix[3][4];

二维数组初始化可以有多种方式，例如：

int matrix[3][4] = {
    {1, 2, 3, 4},
    {5, 6, 7, 8},
    {9, 10, 11, 12}
};

也可以按顺序初始化：

int matrix[3][4] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12};

2. 二维数组元素访问 二维数组元素通过两个下标来访问，第一个下标表示行，第二个下标表示列，都从 0 开始。例如，访问 matrix 数组第 2 行第 3 列的元素可以使用 matrix[1][2]。以下是一个遍历二维数组并输出所有元素的示例：

#include <stdio.h>
int main() {
    int matrix[3][4] = {
        {1, 2, 3, 4},
        {5, 6, 7, 8},
        {9, 10, 11, 12}
    };
    for (int i = 0; i < 3; i++) {
        for (int j = 0; j < 4; j++) {
            printf("Element at (%d, %d) is: %d\t", i, j, matrix[i][j]);
        }
        printf("\n");
    }
    return 0;
}

在这个嵌套的 for 循环中，外层循环控制行，内层循环控制列，从而遍历并输出二维数组 matrix 的所有元素。

指针

指针基础

1. 指针定义与初始化 指针是一种变量，它存储的是另一个变量的内存地址。定义指针的语法为：

data_type *pointer_name;

例如，定义一个指向 int 类型变量的指针：

int *ptr;

指针在使用前需要初始化，即让它指向一个实际的变量。例如：

#include <stdio.h>
int main() {
    int num = 10;
    int *ptr = &num;
    printf("The address of num is: %p\n", (void *)ptr);
    printf("The value of num through pointer is: %d\n", *ptr);
    return 0;
}

在这个例子中，ptr 是一个指向 int 类型变量的指针，通过 & 运算符获取 num 的地址并赋给 ptr。通过 * 运算符可以访问指针所指向的变量的值。

2. 指针运算 指针可以进行一些运算，主要包括指针的算术运算和关系运算。
   • 算术运算：指针的算术运算主要是加减整数。例如，ptr++ 会使指针指向下一个同类型的变量，这是因为指针的移动距离是根据其所指向的数据类型的大小来确定的。假设 ptr 是一个指向 int 类型变量的指针，在 32 位系统中，int 类型通常占用 4 字节，ptr++ 会使 ptr 的值增加 4 字节。
   • 关系运算：指针可以进行关系运算，如 ==、!=、<、> 等，用于比较两个指针是否指向同一个地址或哪个指针的地址值更大。例如：

#include <stdio.h>
int main() {
    int num1 = 10, num2 = 20;
    int *ptr1 = &num1, *ptr2 = &num2;
    if (ptr1 < ptr2) {
        printf("ptr1's address is less than ptr2's address.\n");
    } else if (ptr1 > ptr2) {
        printf("ptr1's address is greater than ptr2's address.\n");
    } else {
        printf("ptr1 and ptr2 have the same address.\n");
    }
    return 0;
}

在这个例子中，比较了两个指针 ptr1 和 ptr2 的地址大小关系。

指针与数组

1. 数组名作为指针 在 C 语言中，数组名可以看作是一个指向数组首元素的常量指针。例如，对于数组 int numbers[5]，numbers 就相当于 &numbers[0]。可以通过指针方式访问数组元素，例如：

#include <stdio.h>
int main() {
    int numbers[] = {1, 2, 3, 4, 5};
    int *ptr = numbers;
    for (int i = 0; i < 5; i++) {
        printf("Element at index %d is: %d\n", i, *(ptr + i));
    }
    return 0;
}

在这个例子中，ptr 指向数组 numbers 的首元素，通过 *(ptr + i) 来访问数组元素，这与 numbers[i] 的效果是一样的。

2. 指针数组 指针数组是一个数组，其元素都是指针。定义指针数组的语法为：

data_type *array_name[size];

例如，定义一个包含 3 个指向 char 类型变量的指针的数组：

char *strings[3];

指针数组常用于处理字符串数组，因为每个字符串的长度可能不同，使用指针数组可以更灵活地管理。例如：

#include <stdio.h>
int main() {
    char *strings[] = {"apple", "banana", "cherry"};
    for (int i = 0; i < 3; i++) {
        printf("String %d is: %s\n", i + 1, strings[i]);
    }
    return 0;
}

在这个例子中，strings 是一个指针数组，每个元素指向一个字符串常量。通过循环遍历指针数组，可以输出每个字符串。

结构体与共用体

结构体

1. 结构体定义与声明 结构体是一种用户自定义的数据类型，它可以将不同类型的数据组合在一起。定义结构体的语法为：

struct structure_name {
    data_type member1;
    data_type member2;
    // 更多成员
};

例如，定义一个表示学生信息的结构体：

struct student {
    char name[50];
    int age;
    float grade;
};

声明结构体变量有以下几种方式：

struct student stu1; // 直接声明
struct student {
    char name[50];
    int age;
    float grade;
} stu2; // 定义同时声明
struct {
    char name[50];
    int age;
    float grade;
} stu3; // 匿名结构体声明

2. 结构体成员访问 通过结构体变量名和成员运算符 . 可以访问结构体的成员。例如：

#include <stdio.h>
struct student {
    char name[50];
    int age;
    float grade;
};
int main() {
    struct student stu;
    strcpy(stu.name, "John");
    stu.age = 20;
    stu.grade = 3.5;
    printf("Student name: %s\n", stu.name);
    printf("Student age: %d\n", stu.age);
    printf("Student grade: %.2f\n", stu.grade);
    return 0;
}

在这个例子中，使用 strcpy 函数给 stu.name 赋值字符串，然后通过 . 运算符访问并输出结构体 stu 的各个成员。

共用体

1. 共用体定义与声明 共用体也是一种用户自定义的数据类型，它允许不同类型的数据共享同一块内存空间。定义共用体的语法为：

union union_name {
    data_type member1;
    data_type member2;
    // 更多成员
};

例如，定义一个共用体：

union data {
    int num;
    float f_num;
    char ch;
};

声明共用体变量的方式与结构体类似：

union data data1; // 直接声明
union data {
    int num;
    float f_num;
    char ch;
} data2; // 定义同时声明
union {
    int num;
    float f_num;
    char ch;
} data3; // 匿名共用体声明

2. 共用体成员访问 共用体只能在同一时间存储一个成员的值。通过共用体变量名和成员运算符 . 来访问成员。例如：

#include <stdio.h>
union data {
    int num;
    float f_num;
    char ch;
};
int main() {
    union data my_data;
    my_data.num = 10;
    printf("The value as int: %d\n", my_data.num);
    my_data.f_num = 3.14f;
    printf("The value as float: %f\n", my_data.f_num);
    my_data.ch = 'A';
    printf("The value as char: %c\n", my_data.ch);
    return 0;
}

在这个例子中，先给 my_data.num 赋值，然后输出其值；接着给 my_data.f_num 赋值并输出，此时 my_data.num 的值已经被覆盖；最后给 my_data.ch 赋值并输出，my_data.f_num 的值也被覆盖。

文件操作

文件打开与关闭

1. 文件打开 在 C 语言中，使用 fopen 函数打开文件。其原型为：

FILE *fopen(const char *filename, const char *mode);

filename 是要打开的文件名，mode 是打开文件的模式。常见的模式有：

• "r"：只读模式，用于读取文件，文件必须存在。
• "w"：只写模式，用于写入文件，如果文件已存在则清空文件内容，若不存在则创建新文件。
• "a"：追加模式，用于在文件末尾追加内容，若文件不存在则创建新文件。 例如，以只读模式打开一个文本文件：

#include <stdio.h>
int main() {
    FILE *file = fopen("example.txt", "r");
    if (file == NULL) {
        perror("Error opening file");
        return 1;
    }
    // 文件操作
    fclose(file);
    return 0;
}

在这个例子中，使用 fopen 函数打开 example.txt 文件，如果打开失败，fopen 会返回 NULL，通过 perror 函数输出错误信息。

2. 文件关闭 使用 fclose 函数关闭文件，其原型为：

int fclose(FILE *stream);

关闭文件可以释放系统资源，确保数据的完整性。例如上述代码中在文件操作完成后使用 fclose(file) 关闭文件。

文件读写

1. 字符读写
   • fgetc 函数：用于从文件中读取一个字符，其原型为：

int fgetc(FILE *stream);

例如，读取一个文本文件的内容并输出：

#include <stdio.h>
int main() {
    FILE *file = fopen("example.txt", "r");
    if (file == NULL) {
        perror("Error opening file");
        return 1;
    }
    int ch;
    while ((ch = fgetc(file))!= EOF) {
        putchar(ch);
    }
    fclose(file);
    return 0;
}

在这个例子中，通过 fgetc 函数从文件中逐字符读取，直到遇到文件结束标志 EOF，并使用 putchar 函数输出读取到的字符。

• fputc 函数：用于向文件中写入一个字符，其原型为：

int fputc(int c, FILE *stream);

例如，向一个文本文件中写入字符：

#include <stdio.h>
int main() {
    FILE *file = fopen("example.txt", "w");
    if (file == NULL) {
        perror("Error opening file");
        return 1;
    }
    char str[] = "Hello, World!";
    for (int i = 0; str[i]!= '\0'; i++) {
        fputc(str[i], file);
    }
    fclose(file);
    return 0;
}

在这个例子中，通过 fputc 函数将字符串 str 中的字符逐个写入文件 example.txt 中。

2. 字符串读写
   • fgets 函数：用于从文件中读取一行字符串，其原型为：

char *fgets(char *str, int num, FILE *stream);

str 是存储读取字符串的缓冲区，num 是读取的最大字符数（包括 \0）。例如，读取一个文本文件的每一行并输出：

#include <stdio.h>
int main() {
    FILE *file = fopen("example.txt", "r");
    if (file == NULL) {
        perror("Error opening file");
        return 1;
    }
    char buffer[100];
    while (fgets(buffer, 100, file)!= NULL) {
        printf("%s", buffer);
    }
    fclose(file);
    return 0;
}

在这个例子中，通过 fgets 函数每次读取一行到 buffer 中，直到文件结束，然后输出读取到的行。

• fputs 函数：用于向文件中写入一个字符串，其原型为：

int fputs(const char *str, FILE *stream);

例如，向一个文本文件中写入字符串：

#include <stdio.h>
int main() {
    FILE *file = fopen("example.txt", "w");
    if (file == NULL) {
        perror("Error opening file");
        return 1;
    }
    char str[] = "Hello, World!";
    fputs(str, file);
    fclose(file);
    return 0;
}

在这个例子中，使用 fputs 函数将字符串 str 写入文件 example.txt 中。

3. 格式化读写
   • fscanf 函数：用于从文件中按指定格式读取数据，其原型为：

int fscanf(FILE *stream, const char *format,...);

例如，从一个包含整数和浮点数的文件中读取数据：

#include <stdio.h>
int main() {
    FILE *file = fopen("example.txt", "r");
    if (file == NULL) {
        perror("Error opening file");
        return 1;
    }
    int num;
    float f_num;
    fscanf(file, "%d %f", &num, &f_num);
    printf("Read integer: %d, float: %f\n", num, f_num);
    fclose(file);
    return 0;
}

在这个例子中，假设 example.txt 文件中有一行内容为 10 3.14，通过 fscanf 函数按 %d %f 的格式读取整数和浮点数。

• fprintf 函数：用于向文件中按指定格式写入数据，其原型为：

int fprintf(FILE *stream, const char *format,...);

例如，向一个文件中写入格式化的数据：

#include <stdio.h>
int main() {
    FILE *file = fopen("example.txt", "w");
    if (file == NULL) {
        perror("Error opening file");
        return 1;
    }
    int num = 10;
    float f_num = 3.14f;
    fprintf(file, "Integer: %d, Float: %f", num, f_num);
    fclose(file);
    return 0;
}

在这个例子中，使用 fprintf 函数将整数 num 和浮点数 f_num 按指定格式写入文件 example.txt 中。