C语言极快回顾一

前言

在Android音视频开发中，网上知识点过于零碎，自学起来难度非常大，不过音视频大牛Jhuster提出了《Android 音视频从入门到提高 - 任务列表》，结合我自己的工作学习经历，我准备写一个音视频系列blog。C/C 是音视频必备编程语言，我准备用几篇文章来快速回顾C语言。本文是音视频系列blog的其中一个， 对应的要学习的内容是：快速回顾C语言的变量和赋值，printf函数和scanf函数，判断语句，循环语句，基本数据类型，数组，函数。

---

音视频系列blog

音视频系列blog: 点击此处跳转查看

---

目录

---

1 C语言第一个程序

第一个程序肯定是输出“Hello World”，程序中永恒的经典！！！

在C语言中，要输出 “Hello World”，可以使用标准库函数 printf。以下是一个简单的示例代码：

#include <stdio.h>

int main() {
    printf("Hello World\n");
    return 0;
}

运行之后，可以看到输出的 “Hello World”。

---

2 变量和赋值

2.1 变量

在C语言中，变量是一种用于存储数据值的命名位置。每个变量都有一个特定的数据类型，如整数、字符、浮点数等，以确定变量可以存储的数据类型和所占用的内存大小。变量在程序中用于存储、操作和处理数据。

以下是关于C语言变量的一些重要信息：

1. 变量声明： 在使用变量之前，需要声明变量的名称和数据类型。变量声明的一般格式是：数据类型 变量名;，例如：int age; 表示声明了一个名为"age"的整数型变量。
2. 变量赋值： 在声明变量后，可以通过赋值操作将值存储到变量中。例如：age = 25; 表示将整数值25存储在变量"age"中。
3. 变量初始化： 变量声明的同时也可以进行初始化，即在声明变量时赋予初始值。例如：int score = 100; 表示声明一个名为"score"的整数型变量，并将初始值设为100。
4. 变量命名规则： C语言变量的命名必须遵循一定的规则，如变量名只能由字母、数字和下划线组成，不能以数字开头，区分大小写等。
5. 数据类型： C语言提供了多种数据类型，包括基本数据类型（如整数、浮点数、字符）以及派生数据类型（如数组、结构体、指针）。不同数据类型具有不同的取值范围和所占内存大小。
6. 作用域： 变量的作用域指的是变量在程序中可见的范围。C语言中有局部变量和全局变量两种，局部变量只在特定代码块内可见，而全局变量在整个程序中都可见。
7. const关键字： 使用const关键字可以声明一个常量，即一个不可更改的变量。常量的值在程序运行过程中不能被修改。
8. sizeof运算符： sizeof运算符用于获取变量或数据类型所占用的字节数。例如：int size = sizeof(int); 表示获取整数类型所占的字节数并存储在变量"size"中。

以下是一些示例：

#include <stdio.h>

int main() {
    int age;           // 声明一个整数型变量
    age = 25;          // 赋值操作
    int score = 100;   // 声明并初始化一个整数型变量
    const double pi = 3.14159;  // 声明一个常量

    printf("Age: %d\n", age);
    printf("Score: %d\n", score);
    printf("Pi: %f\n", pi);

    return 0;
}

以上代码演示了变量的声明、赋值、初始化以及常量的使用。

---

2.2 赋值

在C语言中，赋值是将一个值存储到变量中的过程。赋值操作使用赋值运算符（=）来完成。赋值运算符将右侧的值赋给左侧的变量。

以下是赋值操作的基本语法：

variable = expression;

其中，variable 是要接收赋值的变量，而 expression 是要赋给变量的值或表达式。

例如：

int x;         // 声明一个整数型变量
x = 10;        // 将值10赋给变量x

double pi = 3.14159;  // 声明并初始化一个双精度浮点型变量

你还可以在赋值操作中使用表达式，如：

int a = 5;
int b = 3;
int c = a   b; // 将a加b的结果赋给变量c

需要注意的是，赋值运算是从右向左进行的。即右边的表达式会被计算，然后将计算结果赋给左边的变量。

此外，C语言还支持复合赋值运算符，这些运算符将运算符与赋值操作结合起来，以简化代码。例如：

int num = 10;
num  = 5;  // 等同于 num = num   5;
num *= 2;  // 等同于 num = num * 2;

这些复合赋值运算符可以将操作和赋值合并到一个语句中。

赋值是C语言中重要的操作之一，允许你将值存储在变量中，以便在程序中进行操作和处理。

---

3 printf函数和scanf函数

3.1 printf函数

printf 是C语言中用于输出信息到标准输出（通常是终端或命令行窗口）的函数。它是C标准库中的一个函数，用于在屏幕上显示文本或变量的值。

以下是 printf 函数的基本语法：

#include <stdio.h>  // 包含头文件以使用printf函数

int main() {
    printf("Hello, world!\n");  // 输出字符串并换行
    return 0;
}

在上述示例中，printf 函数输出了字符串 "Hello, world!"，并且使用 \n 进行换行。

printf 函数中可以使用格式控制符来指定输出的格式。一些常见的格式控制符包括：

• %d：用于输出整数。
• %f：用于输出浮点数。
• %c：用于输出字符。
• %s：用于输出字符串。
• %x：用于输出十六进制整数。

以下是一个使用格式控制符的示例：

#include <stdio.h>

int main() {
    int age = 25;
    float height = 175.5;
    char grade = 'A';
    char name[] = "John";

    printf("Age: %d\n", age);
    printf("Height: %.2f\n", height);  // 输出浮点数并控制小数点后的位数
    printf("Grade: %c\n", grade);
    printf("Name: %s\n", name);
    
    return 0;
}

在这个示例中，%d、%.2f、%c 和 %s 是格式控制符，它们会被 printf 函数替换为相应的变量的值。

注意，格式控制符可以带有附加信息，如 .2 在 %f 后面表示要输出的浮点数保留两位小数。

printf 函数是C语言中用于输出内容的重要工具，可以帮助你在屏幕上显示文本、变量值以及格式化信息。

---

3.2 scanf函数

scanf 是C语言中用于从标准输入（通常是键盘）获取输入数据并存储到变量中的函数。它是C标准库中的一个函数，用于读取用户输入的数据。

以下是 scanf 函数的基本语法：

#include <stdio.h>  // 包含头文件以使用scanf函数

int main() {
    int num;
    printf("Enter a number: ");
    scanf("%d", &num);  // 从用户输入读取整数，并将值存储到num变量中
    printf("You entered: %d\n", num);
    
    return 0;
}

在上述示例中，scanf 函数等待用户输入一个整数，并使用 %d 格式控制符将输入的值存储到变量 num 中。需要注意的是，scanf 函数的参数中变量前面需要加上 & 符号，表示取该变量的地址。

如果你想获取多个输入，可以在 scanf 函数中使用多个格式控制符，如：

#include <stdio.h>

int main() {
    int age;
    float height;
    
    printf("Enter your age: ");
    scanf("%d", &age);
    
    printf("Enter your height (in cm): ");
    scanf("%f", &height);
    
    printf("Age: %d, Height: %.2f\n", age, height);
    
    return 0;
}

在输入多个值时，需要确保输入的数据类型与格式控制符相匹配，否则可能会导致错误或意外行为。

需要注意的是，scanf 函数对输入数据的处理可能会有一些限制和安全性问题，例如，它对错误的输入处理不佳。在实际应用中，可能需要添加额外的输入验证来确保输入的数据有效和合理。

scanf 函数是C语言中用于获取用户输入的函数，可以帮助你从标准输入读取数据并存储到变量中。

---

4 if else语句和switch语句

4.1 if else语句

if 和 else 是C语言中用于控制程序流程的条件语句。它们允许你根据条件的真假来执行不同的代码块。

以下是 if 和 else 语句的基本语法：

if (condition) {
    // 如果条件为真，执行这里的代码块
} else {
    // 如果条件为假，执行这里的代码块
}

在上述语法中，condition 是一个表达式，它的值会被判断为真（非零）或假（零）。如果 condition 为真，那么 if 代码块中的代码将被执行。如果 condition 为假，那么 else 代码块中的代码将被执行。

以下是一个简单的例子：

#include <stdio.h>

int main() {
    int num = 10;

    if (num > 0) {
        printf("The number is positive.\n");
    } else {
        printf("The number is non-positive.\n");
    }

    return 0;
}

在这个例子中，如果变量 num 的值大于0，那么会输出 “The number is positive.”，否则会输出 “The number is non-positive.”。

你也可以使用多个 if 和 else if 来构建更复杂的条件判断结构：

#include <stdio.h>

int main() {
    int score;

    printf("Enter your score: ");
    scanf("%d", &score);

    if (score >= 90) {
        printf("Grade: A\n");
    } else if (score >= 80) {
        printf("Grade: B\n");
    } else if (score >= 70) {
        printf("Grade: C\n");
    } else if (score >= 60) {
        printf("Grade: D\n");
    } else {
        printf("Grade: F\n");
    }

    return 0;
}

在这个例子中，根据输入的分数，程序会输出对应的等级。

if 和 else 语句是构建条件逻辑的基础，它们使你可以根据不同的条件执行不同的代码块，从而实现更灵活和有针对性的程序行为。

---

4.2 switch语句

switch 语句是C语言中用于根据不同的条件值执行不同代码块的一种选择结构。它适用于当你有多个固定的选项需要进行选择时，可以将多个条件分支进行组织，使代码更清晰、简洁。

以下是 switch 语句的基本语法：

switch (expression) {
    case constant1:
        // 执行代码块1
        break;
    case constant2:
        // 执行代码块2
        break;
    // 更多 case 分支
    default:
        // 执行默认代码块（可选）
}

在上述语法中，expression 是一个表达式，而 constant1、constant2 等是常量或常量表达式。switch 语句会根据 expression 的值进行匹配，然后根据匹配到的常量执行对应的代码块。如果没有匹配到任何常量，可以使用 default 分支。

以下是一个简单的例子：

#include <stdio.h>

int main() {
    char operator;
    double num1, num2;

    printf("Enter an operator ( , -, *, /): ");
    scanf("%c", &operator);

    printf("Enter two numbers: ");
    scanf("%lf %lf", &num1, &num2);

    switch (operator) {
        case ' ':
            printf("%.2lf   %.2lf = %.2lf\n", num1, num2, num1   num2);
            break;
        case '-':
            printf("%.2lf - %.2lf = %.2lf\n", num1, num2, num1 - num2);
            break;
        case '*':
            printf("%.2lf * %.2lf = %.2lf\n", num1, num2, num1 * num2);
            break;
        case '/':
            if (num2 != 0) {
                printf("%.2lf / %.2lf = %.2lf\n", num1, num2, num1 / num2);
            } else {
                printf("Cannot divide by zero.\n");
            }
            break;
        default:
            printf("Invalid operator.\n");
    }

    return 0;
}

在这个例子中，根据用户输入的操作符，程序使用 switch 语句来选择不同的操作。

需要注意的是，在每个 case 分支的末尾要使用 break 关键字，以防止代码继续执行其他分支。如果没有 break，程序会继续执行后续的分支代码。

---

5 while语句、do语句和 for语句

5.1 while语句

while 是C语言中用于创建循环的一种迭代语句。它允许你根据条件的真假重复执行一段代码块，直到条件不再满足为止。

以下是 while 循环的基本语法：

while (condition) {
    // 循环体，如果条件为真则执行
}

在上述语法中，condition 是一个表达式，如果其值为真（非零），则会重复执行循环体中的代码。当 condition 的值为假（零），循环会终止，程序将继续执行循环后的代码。

以下是一个简单的例子：

#include <stdio.h>

int main() {
    int count = 1;

    while (count <= 5) {
        printf("Count: %d\n", count);
        count  ;
    }

    return 0;
}

在这个例子中，count 从 1 开始递增，当 count 小于等于 5 时，循环会一直重复执行输出 Count 的值，并递增 count 直到达到 6。需要注意的是，如果 condition 一开始就为假，while 循环的代码块可能永远不会被执行。

你可以使用 while 循环来处理不确定次数的迭代，只要条件满足，循环会一直运行。为了防止无限循环，确保在循环体内改变循环条件或者使用适当的控制语句来终止循环。

---

5.2 do语句

当使用 do…while 语句时，循环体中的代码会至少被执行一次，然后在循环结束时检查循环条件。这使得 do…while 循环在一些特定场景下非常有用，例如需要至少执行一次某个操作，然后根据条件判断是否继续执行。

以下是一个示例，展示了如何使用 do…while 循环来获取用户输入并验证输入的有效性：

#include <stdio.h>

int main() {
    int number;

    do {
        printf("Enter a positive number: ");
        scanf("%d", &number);

        if (number <= 0) {
            printf("Invalid input. Please enter a positive number.\n");
        }
    } while (number <= 0);

    printf("You entered a positive number: %d\n", number);

    return 0;
}

在这个例子中，循环体首先要求用户输入一个数字，然后检查该数字是否为正数。如果输入的数字不是正数，循环会继续执行，要求用户重新输入，直到输入的数字是正数为止。

需要注意的是，do…while 循环在判断循环条件之前至少会执行一次循环体中的代码。这与其他循环结构（如 while 循环）不同，其他循环结构会在判断循环条件之前检查是否要执行循环体。

do…while 循环在需要至少执行一次循环体的情况下很有用，可以保证在检查循环条件之前，循环体内的代码至少会被执行一次。

---

5.3 for语句

for 是C语言中用于创建循环的一种迭代语句，它提供了一种简洁的方式来控制循环的初始化、条件和递增。

以下是 for 循环的基本语法：

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

在上述语法中，initialization 是循环初始化的表达式，它在循环开始之前被执行一次。condition 是循环的条件表达式，如果条件为真（非零），则循环体会被执行。increment 是循环递增表达式，它在每次循环迭代结束后被执行。

以下是一个简单的例子：

#include <stdio.h>

int main() {
    for (int i = 1; i <= 5; i  ) {
        printf("Iteration: %d\n", i);
    }

    return 0;
}

在这个例子中，for 循环从 i 初始化为 1 开始，然后在 i 小于等于 5 的条件下重复执行循环体。在每次循环迭代结束后，i 会递增一次。

你可以根据需要在 initialization、condition 和 increment 部分编写相应的表达式，以控制循环的行为。例如，你可以创建从任意起始值到任意结束值的循环，也可以使用负值或浮点数作为循环控制。

以下是一个计算阶乘的例子，使用 for 循环：

#include <stdio.h>

int main() {
    int n;
    int factorial = 1;

    printf("Enter a positive integer: ");
    scanf("%d", &n);

    for (int i = 1; i <= n; i  ) {
        factorial *= i;
    }

    printf("Factorial of %d: %d\n", n, factorial);

    return 0;
}

在这个例子中，for 循环用于计算给定正整数的阶乘。循环从 1 到输入的整数 n 进行迭代，并将每次迭代的值乘到 factorial 中。

for 循环是C语言中用于控制循环的一种强大方式，它提供了初始化、条件和递增的结构，使得循环逻辑更加紧凑。

---

6 基本数据类型

C语言中的基本数据类型用于存储不同种类的数据，如整数、浮点数、字符等。这些基本数据类型可以用于声明变量、函数参数和返回值等。

以下是C语言中常见的基本数据类型：

1. 整数类型：

   • int：整数类型，通常占用4个字节（32位）的内存。
   • short：短整数类型，通常占用2个字节（16位）的内存。
   • long：长整数类型，占用4个字节或8个字节的内存，具体取决于编译器和操作系统。
   • long long：更长的整数类型，通常占用8个字节的内存。

2. 无符号整数类型：

   • unsigned int：无符号整数类型，存储非负整数。
   • unsigned short：无符号短整数类型。
   • unsigned long：无符号长整数类型。
   • unsigned long long：无符号更长的整数类型。

3. 字符类型：

   • char：字符类型，通常占用1个字节的内存，用于存储ASCII码中的字符。

4. 浮点数类型：

   • float：单精度浮点数类型，通常占用4个字节的内存，用于存储小数。
   • double：双精度浮点数类型，通常占用8个字节的内存，提供更高的精度。

5. 布尔类型：

   • bool（需要包含 <stdbool.h> 头文件）：布尔类型，存储 true 或 false 值。

C语言的标准库还定义了一些用于表示内存大小和数据范围的宏，如 sizeof 运算符用于获取数据类型的字节数，INT_MAX 和 INT_MIN 分别表示 int 类型的最大和最小值等。

例如，以下代码演示了如何声明不同的基本数据类型的变量和使用一些宏：

#include <stdio.h>
#include <limits.h>   // 包含一些整数类型的范围宏

int main() {
    int myInt = 42;
    char myChar = 'A';
    float myFloat = 3.14;
    double myDouble = 2.71828;
    bool myBool = true;

    printf("Size of int: %lu bytes\n", sizeof(int));
    printf("Size of char: %lu bytes\n", sizeof(char));
    printf("Size of float: %lu bytes\n", sizeof(float));
    printf("Size of double: %lu bytes\n", sizeof(double));
    printf("Size of bool: %lu byte\n", sizeof(bool));

    printf("Maximum value of int: %d\n", INT_MAX);
    printf("Minimum value of int: %d\n", INT_MIN);

    return 0;
}

在上述示例中，我们展示了不同数据类型的声明、sizeof 运算符的使用以及一些整数范围的宏。

---

7 数组

7.1 一维数组

在C语言中，一维数组是一种用于存储相同数据类型元素的线性数据结构。数组允许你在一个变量中存储多个相同类型的值，并通过索引访问这些值。数组的索引从0开始，逐渐递增。

以下是一维数组的基本语法：

data_type array_name[array_size];

在上述语法中，data_type 是数组中元素的数据类型，array_name 是数组的名称，array_size 是数组的大小，即可以存储的元素个数。

以下是一个示例，展示如何声明、初始化和访问一维数组：

#include <stdio.h>

int main() {
    int numbers[5];  // 声明一个包含5个整数的数组

    // 初始化数组
    numbers[0] = 10;
    numbers[1] = 20;
    numbers[2] = 30;
    numbers[3] = 40;
    numbers[4] = 50;

    // 访问和输出数组元素
    printf("Element at index 0: %d\n", numbers[0]);
    printf("Element at index 1: %d\n", numbers[1]);
    printf("Element at index 2: %d\n", numbers[2]);
    printf("Element at index 3: %d\n", numbers[3]);
    printf("Element at index 4: %d\n", numbers[4]);

    return 0;
}

在这个示例中，我们声明了一个名为 numbers 的整数数组，然后初始化数组的各个元素，最后通过索引访问并输出了数组中的元素。

你也可以在声明数组时同时进行初始化：

int numbers[5] = {10, 20, 30, 40, 50};

如果不显式提供初始化值，数组的元素将会被自动初始化为0（对于数字类型）或者空字符 '\0'（对于字符类型）。

一维数组在C语言中是非常常用的数据结构，用于存储列表、序列和集合等数据。数组的索引从0开始，注意在访问数组元素时，索引不能超出数组的范围，否则可能导致未定义的行为。

---

7.2 二维数组

二维数组是C语言中的一种数据结构，用于存储表格形式的数据，即具有行和列的数据。二维数组实际上是由多个一维数组组成的，每个一维数组代表二维数组的一行。

以下是二维数组的基本语法：

data_type array_name[row_size][column_size];

在上述语法中，data_type 是数组中元素的数据类型，array_name 是数组的名称，row_size 是数组的行数，column_size 是数组的列数。

以下是一个示例，展示如何声明、初始化和访问二维数组：

#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("%d ", matrix[i][j]);
        }
        printf("\n");
    }

    return 0;
}

在这个示例中，我们声明了一个名为 matrix 的3行4列的整数二维数组，然后初始化数组的各个元素，并使用两层循环来遍历并输出整个二维数组。

你也可以在声明二维数组时省略行数，只指定列数，然后在初始化时根据需要提供行数：

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

二维数组在模拟矩阵、表格等多维数据时非常有用。注意，在访问二维数组元素时，需要使用两个索引来指定行和列的位置。同样要确保索引不超出数组的范围，以避免访问无效内存。

---

7.3 三维数组

三维数组是C语言中的一种高维数据结构，用于存储立体的数据。类似于二维数组，三维数组实际上是由多个二维数组组成的，每个二维数组代表三维数组的一个平面。

以下是三维数组的基本语法：

data_type array_name[depth_size][row_size][column_size];

在上述语法中，data_type 是数组中元素的数据类型，array_name 是数组的名称，depth_size 是数组的深度，row_size 是数组的行数，column_size 是数组的列数。

以下是一个示例，展示如何声明、初始化和访问三维数组：

#include <stdio.h>

int main() {
    int cube[2][3][4] = {
        {
            {1, 2, 3, 4},
            {5, 6, 7, 8},
            {9, 10, 11, 12}
        },
        {
            {13, 14, 15, 16},
            {17, 18, 19, 20},
            {21, 22, 23, 24}
        }
    };

    // 访问和输出三维数组元素
    for (int d = 0; d < 2; d  ) {
        printf("Depth %d:\n", d   1);
        for (int i = 0; i < 3; i  ) {
            for (int j = 0; j < 4; j  ) {
                printf("%d ", cube[d][i][j]);
            }
            printf("\n");
        }
        printf("\n");
    }

    return 0;
}

在这个示例中，我们声明了一个名为 cube 的2层3行4列的整数三维数组，然后初始化数组的各个元素，并使用三层循环来遍历并输出整个三维数组。

三维数组在模拟立体的数据、图像处理等领域非常有用。注意，在访问三维数组元素时，需要使用三个索引来指定深度、行和列的位置。同样要确保索引不超出数组的范围，以避免访问无效内存。

---

8 函数

8.1 函数定义与使用

函数是C语言中的重要概念，用于将代码组织成可重用、模块化的块。函数允许你将一段特定的功能代码封装起来，并在需要时通过调用函数来执行该功能。

以下是定义和调用函数的基本语法：

return_type function_name(parameters) {
    // 函数体，执行具体功能
    // 可以包含多条语句
    return value; // 返回值（可选）
}

在上述语法中：

• return_type 是函数的返回类型，指定函数返回的数据类型（如 int、float、void 等）。
• function_name 是函数的名称，用于在其他地方调用函数。
• parameters 是函数的参数列表，用于接收函数调用时传递的参数。
• return value（可选）是函数的返回语句，用于返回一个值给调用者。

以下是一个示例，展示如何定义和调用一个简单的函数：

#include <stdio.h>

// 函数定义
int add(int a, int b) {
    int result = a   b;
    return result;
}

int main() {
    int num1 = 5, num2 = 7;

    // 调用函数并将返回值赋给变量
    int sum = add(num1, num2);

    printf("Sum: %d\n", sum);

    return 0;
}

在这个示例中，我们定义了一个名为 add 的函数，它接受两个整数参数并返回它们的和。然后在 main 函数中调用了这个函数，并将返回的结果赋给变量 sum，然后输出了和。

需要注意的是，函数需要在调用之前进行声明或定义。如果函数定义在 main 函数之后，你需要在 main 函数之前提供函数的原型声明。函数的参数和返回类型在声明和定义时需要一致。

C语言中的函数允许你将代码划分成更小的模块，提高了代码的可维护性和可读性。它们还可以被多次调用，使代码得到重复使用。

---

8.2 函数的参数

函数的参数是在函数定义中用于接收传递给函数的值的变量。参数允许你在函数内部使用外部传入的数据，从而实现更通用和可定制的函数功能。

C语言中函数的参数可以分为两种类型：形式参数（也称为形参）和实际参数（也称为实参）。

1. 形式参数（形参）：
   形式参数是函数定义中声明的参数，用于接收传递给函数的值。形式参数只在函数内部起作用，它们的值在函数调用时由实际参数传递。

   形式参数的声明方式通常在函数的原型和定义中的参数列表中，例如：

   int add(int a, int b) {
       // 函数体
   }
   

2. 实际参数（实参）：
   实际参数是在函数调用时提供的参数值。实际参数可以是常量、变量、表达式等。在函数调用时，实际参数的值被传递给形式参数，从而函数可以使用这些值进行计算或处理。

   在调用函数时，实际参数可以按照形式参数的顺序进行传递，例如：

   int main() {
       int result = add(5, 7); // 5和7是实际参数
       // ...
   }
   

函数的参数使得函数能够处理不同的数据，并根据传入的值执行相应的操作。在函数定义中，你可以在形式参数的位置使用这些参数，就像使用普通的变量一样。调用函数时，实际参数的值会被复制到形式参数中，从而函数可以使用它们执行操作。

需要注意的是，参数的数据类型和顺序在函数声明和调用时必须一致。参数的名称可以在函数定义和调用中不同，名称只在函数内部起作用。

这篇好文章是转载于：学新通技术网