C语言中那些眼花缭乱的操作符-3

最新推荐文章于 2025-05-28 20:03:32 发布

奔跑de自由

最新推荐文章于 2025-05-28 20:03:32 发布

阅读量1.1k

点赞数 20

分类专栏： C语言学习文章标签： c语言开发语言

本文链接：https://blog.csdn.net/lxy370198409/article/details/144120858

版权

C语言学习专栏收录该内容

23 篇文章

订阅专栏

文章目录

前言
一、移位操作符
- 1、左移操作（`<<`）
- 2、右移操作（`>>`）
二、位操作符
三、逗号表达式
四、函数调用操作符
五、下标操作符
六、操作符的优先级和结合性
七、总结

前言

通过前两次对操作符的介绍，对于平时经常使用的操作符有了一定的了解，下面来介绍一下另外一些经常使用的操作符，尤其在嵌入式C语言中，更是如日常工具般经常使用。
C语言中那些眼花缭乱的操作符-1
C语言中那些眼花缭乱的操作符-2

一、移位操作符

在 C 语言中，移位操作符用于对二进制位进行操作。它有两种类型：左移操作符（ << ）和右移操作符（ >> ）。这些操作符主要用于对整数类型（如char、short、int、long等）的数据进行位级别的操作，它们的操作数是整数。

1、左移操作（`<<`）

将一个数的二进制位向左移动指定的位数。移动后，右边空出的位用0填充。例如，将二进制数101（十进制为5）左移1位，就变成1010（十进制为10）。
移位规则：左边舍弃，右边补“0”。
示例代码：

#include <stdio.h>
int main()
{
    int num = 5;  // 二进制表示为00000101
    int result = num << 2;  // 将num左移2位
    printf("原始数字: %d\n", num);
    printf("左移2位后的结果: %d\n", result);
    return 0;
}

运行结果
解释：
- 在这个例子中，num的初始值为5，其二进制表示是00000101。
- 当执行num << 2操作时，将num的二进制位向左移动2位，得到00010100，对应的十进制数是20。
- 最后通过printf函数输出原始数字和左移后的结果。

2、右移操作（`>>`）

将一个数的二进制位向右移动指定的位数。对于无符号数，左边空出的位用0填充；对于有符号数，情况比较复杂，不同的编译器可能采用不同的方式。
最常见的是算术右移，即左边空出的位用符号位（最高位）填充，以保持数的符号不变。例如，对于有符号数-4（二进制为11111100）算术右移1位得到11111110（十进制为 -2）。

还有一种右移方法叫逻辑右移，左边用0填充，右侧舍弃，但这种右移方式有时会改变值的正负，且很少采用，故不多做赘述了。

对于无符号数的右移示例：

#include <stdio.h>
int main()
{
    unsigned int num = 16;  // 二进制表示为00010000
    unsigned int result = num >> 2;  // 将num右移2位
    printf("原始数字: %u\n", num);
    printf("右移2位后的结果: %u\n", result);
    return 0;
}

解释：
- 这里num是一个无符号整数，初始值为16，二进制表示为00010000。
- 执行num >> 2操作时，将num的二进制位向右移动2位，左边空出的位用0填充，得到00000100，对应的十进制数是4。
- 通过printf函数输出原始数字和右移后的结果，注意%u用于输出无符号整数。
对于有符号数的右移示例：

#include <stdio.h>
int main()
{
    int num = -8;  // 二进制表示（补码形式）为11111000
    int result = num >> 1;  // 将num右移1位
    printf("原始数字: %d\n", num);
    printf("右移1位后的结果: %d\n", result);
    return 0;
}

解释：
- num是一个有符号整数，值为 -8，在计算机中以补码形式存储，其二进制表示为11111000。
- 执行num >> 1操作时，采用算术右移，左边空出的位用符号位（最高位，这里是1）填充，得到11111100，对应的十进制数是 -4。
- 最后输出原始数字和右移后的结果。

二、位操作符

1、位操作符概述

C语言提供了位操作符用于对整数类型数据的二进制位进行操作。这些操作符允许直接在二进制级别处理数据，能够实现高效的底层操作，比如对硬件寄存器的控制、数据加密、压缩算法等方面都有广泛应用。位操作符包括位与（&）、位或（|）、位异或（^）、取反（~）、左移（<<）和右移（>>）。

2、位与操作符（`&`）

功能：对两个操作数的二进制位进行与运算。只有当两个相应位都为1时，结果位才为1，否则为0。
示例：

#include <stdio.h>
int main()
{
    int num1 = 5;   // 二进制表示为00000101
    int num2 = 3;   // 二进制表示为00000011
    int result = num1 & num2;
    // 按位与运算：00000101 & 00000011 = 00000001
    printf("num1 & num2的结果是：%d\n", result);
    return 0;
}

解释：
- 在这个例子中，num1的值为5，二进制是00000101，num2的值为3，二进制是00000011。
- 进行位与运算时，从最低位开始，第一位都是1，所以结果的第一位是1；第二位num1是0，num2是1，所以结果的第二位是0；第三位num1是1，num2是0，所以结果的第三位是0；第四位num1是0，num2是0，所以结果的第四位是0。最终得到的二进制结果是00000001，十进制为1。

3、位或操作符（`|`）

功能：对两个操作数的二进制位进行或运算。只要两个相应位中有一个为1，结果位就为1。
示例：

#include <stdio.h>
int main()
{
    int num1 = 5;   // 二进制表示为00000101
    int num2 = 3;   // 二进制表示为00000011
    int result = num1 | num2;
    // 按位或运算：00000101 | 00000011 = 00000111
    printf("num1 | num2的结果是：%d\n", result);
    return 0;
}

解释：
- 同样num1为5（二进制00000101），num2为3（二进制00000011）。
- 进行位或运算时，从最低位开始，第一位两个数都是1，结果的第一位是1；第二位num1是0，num2是1，结果的第二位是1；第三位num1是1，num2是0，结果的第三位是1；第四位num1是0，num2是0，结果的第四位是0。最终得到二进制结果00000111，十进制为7。

4、位异或操作符（`^`）

功能：对两个操作数的二进制位进行异或运算。当两个相应位不同时，结果位为1，相同时结果位为0。
示例：

#include <stdio.h>
int main()
{
    int num1 = 5;   // 二进制表示为00000101
    int num2 = 3;   // 二进制表示为00000011
    int result = num1 ^ num2;
    // 按位异或运算：00000101 ^ 00000011 = 00000110
    printf("num1 ^ num2的结果是：%d\n", result);
    return 0;
}

解释：
- 对于num1（二进制00000101）和num2（二进制00000011）。
- 从最低位开始，第一位两个数相同，结果的第一位是0；第二位num1是0，num2是1，结果的第二位是1；第三位num1是1，num2是0，结果的第三位是1；第四位num1是0，num2是0，结果的第四位是0。最终得到二进制结果00000110，十进制为6。

5、取反操作符（`~`）

功能：对操作数的二进制位进行取反运算，即0变为1，1变为0。
示例：

#include <stdio.h>
int main()
{
    int num = 5;   // 二进制表示为00000101
    int result = ~num;
    // 按位取反运算：~00000101 = 11111010
    printf("~num的结果是：%d\n", result);
    return 0;
}

解释：
- num的值为5，二进制是00000101。
- 进行取反运算后，得到二进制结果11111010。在有符号整数表示中，这个二进制数是补码形式，转换为十进制是 -6（先减1得到反码11111001，再取反得到原码10000110，符号位为1，表示负数，数值部分为6）。

左移操作符（<<）和右移操作符（>>）（在前面已经介绍过部分内容，这里再详细补充一下）
- 左移操作符（<<）
  - 功能：将一个数的二进制位向左移动指定的位数。移动后，右边空出的位用0填充。相当于乘以2的移动位数次方。
  - 示例：

#include <stdio.h>
int main()
{
    int num = 3;   // 二进制表示为00000011
    int result = num << 2;
    // 左移2位：00000011 << 2 = 00001100
    printf("num << 2的结果是：%d\n", result);
    return 0;
}

 - **解释**：
   - `num`的值为3，二进制是`00000011`。
   - 左移2位后，得到二进制结果`00001100`，十进制为12，正好是3乘以$2^2$。

右移操作符（>>）
- 功能：将一个数的二进制位向右移动指定的位数。对于无符号数，左边空出的位用0填充；对于有符号数，最常见的是算术右移，即左边空出的位用符号位（最高位）填充，以保持数的符号不变，相当于除以2的移动位数次方（向下取整）。
- 示例：

#include <stdio.h>
int main()
{
    int num = -8;   // 二进制表示（补码形式）为11111000
    int result = num >> 1;
    // 算术右移1位：11111000 >> 1 = 11111100
    printf("num >> 1的结果是：%d\n", result);
    return 0;
}

 - **解释**：
   - `num`的值为 -8，在计算机中以补码形式存储，二进制是`11111000`。
   - 进行算术右移1位操作，左边空出的位用符号位（1）填充，得到二进制结果`11111100`，十进制为 -4，相当于 -8除以2（向下取整）。

三、逗号表达式

1、逗号表达式的基本概念

在C语言中，逗号表达式是一种特殊的表达式，它允许将多个表达式组合在一起。逗号表达式的一般形式为：表达式1, 表达式2, 表达式3, …, 表达式n。这些表达式从左到右依次求值，整个逗号表达式的值是最后一个表达式（表达式n）的值。
逗号运算符的优先级是所有运算符中最低的，它主要用于需要按顺序执行多个操作，但最终只关注最后一个操作结果的情况。例如，在初始化多个变量或者在for循环的初始化和迭代部分，可以巧妙地利用逗号表达式。

2、逗号表达式在变量初始化中的应用

示例：

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

解释：
- 在这个例子中，a = 1, b = 2, c = 3是一个逗号表达式。首先执行a = 1，将a赋值为1；接着执行b = 2，将b赋值为2；最后执行c = 3，将c赋值为3。整个逗号表达式的值是最后一个表达式c = 3的值，但在这个例子中，我们并没有使用这个整体的值，而是通过printf函数分别输出了a、b和c的值。

3、逗号表达式在`for`循环中的应用

示例：

#include <stdio.h>
int main()
{
    int i, sum;
    for (i = 1, sum = 0; i <= 5; i++)
    {
        sum += i;
    }
    printf("1到5的累加和为：%d\n", sum);
    return 0;
}

解释：
- 在for循环的初始化部分i = 1, sum = 0是一个逗号表达式。它先执行i = 1，初始化循环变量i为1，然后执行sum = 0，初始化变量sum为0。在每次循环迭代中，i的值从1递增到5，同时sum累加i的值。当i超过5时，循环结束。最终通过printf函数输出1到5的累加和。
- 这里使用逗号表达式可以在for循环的初始化部分方便地对多个变量进行初始化操作。

4、逗号表达式的嵌套使用

示例：

#include <stdio.h>
int main()
{
    int x, y, z;
    x = (y = 3, z = 5, y + z);
    printf("x = %d\n", x);
    return 0;
}

解释：
- 对于表达式x = (y = 3, z = 5, y + z)，首先在括号内的逗号表达式中，先执行y = 3，将y赋值为3；接着执行z = 5，将z赋值为5；最后执行y + z，计算结果为8。整个括号内逗号表达式的值为8，然后将这个值赋给x。所以最后输出x的值为8。
- 这种嵌套的逗号表达式可以实现更复杂的顺序求值和赋值操作。

5、逗号表达式与函数参数的关系

示例：

#include <stdio.h>
int add(int a, int b)
{
    return a + b;
}
int main()
{
    int result;
    result = add((1, 2), (3, 4));
    printf("result = %d\n", result);
    return 0;
}

解释：
- 在函数调用add((1, 2), (3, 4))中，参数部分(1, 2)和(3, 4)都是逗号表达式。对于(1, 2)，先执行1，然后执行2，整个表达式的值为2；对于(3, 4)，先执行3，然后执行4，整个表达式的值为4。所以实际上函数调用等价于add(2, 4)，函数add将两个参数相加，返回6，最后将6赋值给result并输出。
- 需要注意的是，在这种情况下，要清楚逗号表达式在函数参数传递中的求值方式，避免出现误解。

四、函数调用操作符

1、函数调用操作符的基本概念

在C语言中，函数调用操作符是一对圆括号()。当你定义了一个函数后，使用函数调用操作符来执行这个函数，它的主要作用是传递参数给函数，并获取函数执行后的返回值（如果函数有返回值的话）。函数调用操作符紧跟在函数名之后，圆括号内是传递给函数的参数列表，参数之间用逗号隔开。

2、无参数函数的调用

示例：

#include <stdio.h>

// 定义一个无参数函数
void printHello() {
    printf("Hello!\n");
}

int main() {
    // 调用无参数函数
    printHello();
    return 0;
}

解释：
- 首先定义了一个名为printHello的函数，它没有参数，函数体中只有一个printf语句，用于输出字符串"Hello!"。
- 在main函数中，通过printHello();这一语句来调用printHello函数。函数调用操作符()在这里表示执行printHello这个函数，由于函数没有参数，所以括号内为空。当程序执行到这一行时，就会跳转到printHello函数的定义处开始执行函数体中的代码，输出"Hello!"后再返回到main函数中继续执行后面的代码。

3、有参数函数的调用

示例：

#include <stdio.h>

// 定义一个有参数函数，计算两个整数的和
int add(int a, int b) {
    return a + b;
}

int main() {
    int result;
    // 调用有参数函数，传递两个整数作为参数
    result = add(3, 5);
    printf("3和5的和是：%d\n", result);
    return 0;
}

解释：
- 定义了一个名为add的函数，它有两个参数a和b，都是整数类型。函数体中的return a + b;语句表示函数将返回a和b相加的结果。
- 在main函数中，result = add(3, 5);这一语句用于调用add函数。函数调用操作符()内的3和5是传递给add函数的参数，它们会分别被赋值给函数定义中的参数a和b。然后函数执行计算a + b（即3 + 5），得到结果8并返回。这个返回值被赋值给main函数中的result变量，最后通过printf函数输出结果。

4、函数指针与函数调用操作符的结合使用

示例：

#include <stdio.h>

// 定义一个函数，计算两个整数的乘积
int multiply(int a, int b) {
    return a * b;
}

int main() {
    int (*funcPtr)(int, int);
    funcPtr = multiply;
    // 通过函数指针调用函数
    int result = funcPtr(4, 6);
    printf("4和6的乘积是：%d\n", result);
    return 0;
}

解释：
- 首先定义了一个名为multiply的函数，用于计算两个整数的乘积。
- 在main函数中，int (*funcPtr)(int, int);定义了一个函数指针funcPtr，它可以指向一个有两个整数参数并返回一个整数的函数。然后funcPtr = multiply;将funcPtr指向multiply函数。
- 最后int result = funcPtr(4, 6);通过函数指针funcPtr来调用multiply函数。这里的函数调用操作符()的作用和直接调用函数是一样的，只是调用的方式是通过函数指针。参数4和6被传递给multiply函数，计算得到乘积24并返回，赋值给result变量，然后输出结果。

5、函数调用操作符中的参数求值顺序

在C语言标准中，函数调用操作符中参数的求值顺序是未定义的。这意味着不同的编译器可能按照不同的顺序来计算参数表达式的值。
示例：

#include <stdio.h>

int func(int a, int b) {
    return a + b;
}

int main() {
    int x = 2;
    int result = func(x++, ++x);
    printf("result = %d\n", result);
    return 0;
}

解释：
- 定义了一个func函数用于计算两个整数的和。
- 在main函数中，int result = func(x++, ++x);这一语句在调用func函数时，参数x++和++x的求值顺序是不确定的。一种可能是先计算x++，此时x的值为2，然后计算++x，此时x的值变为4，那么函数调用就相当于func(2, 4)，结果为6。但另一种编译器可能先计算++x，然后计算x++，得到不同的结果。所以在编写代码时，应该避免编写依赖参数求值顺序的代码，以确保程序的可移植性和正确性。

五、下标操作符

1、下标操作符的基本概念

在C语言中，下标操作符是一对方括号[]。它主要用于访问数组中的元素。数组是一种数据结构，它存储了一组相同类型的数据元素。通过下标操作符，可以根据元素在数组中的位置（索引）来获取或修改该元素的值。数组的下标从0开始，即第一个元素的下标为0，第二个元素的下标为1，以此类推。

2、一维数组中的下标操作符

示例：

#include <stdio.h>
int main()
{
    int arr[5];  // 定义一个包含5个整数的一维数组
    // 使用下标操作符初始化数组元素
    arr[0] = 1;
    arr[1] = 3;
    arr[2] = 5;
    arr[3] = 7;
    arr[4] = 9;
    // 使用下标操作符访问数组元素并输出
    for (int i = 0; i < 5; i++)
    {
        printf("%d ", arr[i]);
    }
    return 0;
}

解释：
- 首先int arr[5];定义了一个名为arr的一维数组，它可以存储5个整数。
- 然后通过arr[0] = 1;等语句，使用下标操作符[]来访问数组中的元素。这里arr[0]表示数组arr的第一个元素，将其赋值为1；arr[1]表示第二个元素，赋值为3，以此类推。
- 在for循环中，再次使用下标操作符[]来遍历数组。循环变量i从0变化到4，每次循环通过arr[i]来访问数组中的一个元素，并使用printf函数将其输出。

3、二维数组中的下标操作符

示例：

#include <stdio.h>
int main()
{
    int matrix[3][3];  // 定义一个3x3的二维数组
    // 使用下标操作符初始化二维数组元素
    matrix[0][0] = 1;
    matrix[0][1] = 2;
    matrix[0][2] = 3;
    matrix[1][0] = 4;
    matrix[1][1] = 5;
    matrix[1][2] = 6;
    matrix[2][0] = 7;
    matrix[2][1] = 8;
    matrix[2][2] = 9;
    // 使用下标操作符访问二维数组元素并输出
    for (int i = 0; i < 3; i++)
    {
        for (int j = 0; j < 3; j++)
        {
            printf("%d ", matrix[i][j]);
        }
        printf("\n");
    }
    return 0;
}

解释：
- int matrix[3][3];定义了一个二维数组matrix，它可以看作是一个3行3列的矩阵。
- 在初始化部分，matrix[0][0]表示第一行第一列的元素，将其赋值为1；matrix[0][1]表示第一行第二列的元素，赋值为2，以此类推。
- 在嵌套的for循环中，外层循环变量i控制行，内层循环变量j控制列。通过matrix[i][j]来访问二维数组中的每个元素，并使用printf函数输出。例如，当i = 0、j = 0时，访问第一行第一列的元素；当i = 1、j = 2时，访问第二行第三列的元素。

4、字符数组与字符串中的下标操作符

示例：

#include <stdio.h>
int main()
{
    char str[] = "Hello";
    // 使用下标操作符访问字符数组中的元素并输出
    for (int i = 0; str[i]!= '\0'; i++)
    {
        printf("%c", str[i]);
    }
    return 0;
}

解释：
- char str[] = "Hello";定义了一个字符数组str，它存储了字符串"Hello"。在C语言中，字符串是以字符数组的形式存储的，并且以'\0'（空字符）作为字符串的结束标志。
- 在for循环中，通过str[i]来访问字符数组中的每个字符。循环条件str[i]!= '\0'确保在遇到字符串结束标志之前一直循环。每次循环通过printf函数输出一个字符，最终输出整个字符串"Hello"。

5、下标操作符的边界检查

在使用下标操作符时，必须确保下标值在数组的有效范围内。如果下标超出数组的范围，可能会导致程序出现错误，如访问到不该访问的内存区域，可能会引发程序崩溃或者产生不可预测的结果。
示例：

#include <stdio.h>
int main()
{
    int arr[3];
    // 正确使用下标操作符
    arr[0] = 1;
    arr[1] = 2;
    arr[2] = 3;
    // 错误使用：下标超出范围
    // arr[3] = 4; 
    return 0;
}

解释：
- 定义了一个大小为3的数组arr，其有效下标范围是0到2。正确地使用下标操作符可以正常地访问和修改数组元素，如arr[0] = 1;等。
- 如果取消注释arr[3] = 4;这一行，由于3超出了数组arr的下标范围，这会导致程序出现错误。在一些编译器中，可能会直接报错；在其他情况下，可能会导致程序运行时出现不可预测的行为，比如覆盖其他变量的值或者导致程序崩溃。

六、操作符的优先级和结合性

1、操作符优先级

概念：操作符优先级决定了在一个包含多个不同操作符的表达式中，哪个操作符先被执行。就像在数学运算中，乘法和除法通常比加法和减法先运算一样。优先级高的操作符先结合操作数进行运算。
示例：

#include <stdio.h>
int main()
{
    int result = 2 + 3 * 4;
    // 先计算乘法3 * 4 = 12，再计算加法2 + 12 = 14
    printf("结果是：%d\n", result);
    return 0;
}

解释：在表达式2 + 3 * 4中，乘法操作符*的优先级高于加法操作符+。所以先计算3 * 4得到12，然后再计算2 + 12得到14。
常见优先级顺序（从高到低）：
- 一元操作符（如++、--、~、!）。例如!0（逻辑非操作，结果为1）先执行逻辑非操作。
- 算术操作符（*、/、%）优先级高于（+、-）。例如在5 + 3 * 2中先算乘法。
- 关系操作符（>、<、>=、<=、==、!=）。用于比较大小或相等性。
- 逻辑操作符（&&、||）。用于逻辑判断，&&（逻辑与）优先级高于||（逻辑或）。
- 条件操作符（? :）。
- 赋值操作符（=、+=、-=等各种复合赋值操作符）。

2、操作符结合性

概念：当一个表达式中出现多个相同优先级的操作符时，结合性决定了操作符如何组合操作数进行运算。结合性分为左结合性和右结合性。左结合性意味着操作符从左向右依次结合操作数，右结合性则相反。
左结合性示例（加法操作符）：

#include <stdio.h>
int main()
{
    int result = 2 + 3 + 4;
    // 从左向右依次计算：(2 + 3) + 4 = 9
    printf("结果是：%d\n", result);
    return 0;
}

解释：加法操作符+是左结合性的。在表达式2 + 3 + 4中，先计算左边的2 + 3得到5，然后再计算5 + 4得到9。
右结合性示例（赋值操作符）：

#include <stdio.h>
int main()
{
    int a, b, c;
    a = b = c = 5;
    // 从右向左依次赋值：先c = 5，再b = c，最后a = b
    printf("a = %d, b = %d, c = %d\n", a, b, c);
    return 0;
}

解释：赋值操作符=是右结合性的。在表达式a = b = c = 5中，先将5赋给c，然后将c的值赋给b，最后将b的值赋给a，所以a、b、c的值都为5。

3、复杂表达式中的优先级和结合性综合示例

#include <stdio.h>
int main()
{
    int result = 5 * 2 - 3 / 3 + 2;
    // 先算乘法5 * 2 = 10，再算除法3 / 3 = 1
    // 表达式变为10 - 1 + 2
    // 加法和减法是左结合性，先算10 - 1 = 9，再算9 + 2 = 11
    printf("结果是：%d\n", result);
    return 0;
}

解释：
- 首先，根据优先级，乘法*和除法/先于加法+和减法-进行运算。所以先计算5 * 2得到10，3 / 3得到1，此时表达式变为10 - 1 + 2。
- 然后，加法和减法操作符是左结合性的，从左向右依次计算。先计算10 - 1得到9，再计算9 + 2得到最终结果11。

七、总结

在C语言的编程世界里，操作符无疑是最为灵动且关键的元素之一。它们如同魔法师手中的各式法杖，各施其能，赋予代码丰富多样的表现力和强大的运算能力。
从简单的算术操作符让我们能够轻松完成数值的四则运算，到关系操作符精准判别数据间的大小与相等关系，进而引导程序的走向；逻辑操作符巧妙编织复杂的逻辑判断网络，使程序能应对各种条件分支；位操作符深入二进制的微观世界，为底层数据处理和优化提供了有力手段；赋值操作符则稳稳地担当起数据传递与变量更新的重任；自增自减操作符以简洁的方式实现变量的递增递减，让循环等操作更加高效；条件操作符用简洁的语法完成快速的二选一抉择；逗号操作符有条不紊地编排多个表达式的求值顺序。
这些操作符，凭借各自独特的功能以及相互配合所遵循的优先级和结合性规则，共同构建起了C语言程序那千变万化又严谨有序的逻辑架构。只有深入理解并熟练掌握它们，我们才能在C语言的编程海洋里如鱼得水，用代码书写出功能强大、高效稳定的程序，去实现那些脑海中精彩纷呈的创意与构想。无论你是初涉C语言的新手，还是经验丰富的开发者，操作符的精妙运用都将是你编程之旅中不断探索和精进的重要课题。让我们继续在C语言的世界里，凭借对操作符的娴熟驾驭，开启更多精彩的编程篇章吧！