C语言程序的控制结构

C语言程序通过三种基本控制结构构建执行流程：

  • 顺序结构:程序按照代码的书写顺序从上到下依次执行，不重复也不跳过任何语句。
  • 选择结构:选择结构让程序具备了判断能力，根据不同的条件选择执行不同的代码块。
  • 循环结构:循环结构让程序能够反复执行同一段代码直到满足特定条件。
    这三种结构相互配合，构成了程序逻辑的基础框架。

顺序结构

最简单的结构，代码按照书写顺序从上到下依次执行。

1
2
3
4
5
6
7
8
#include <stdio.h>
int main() {
    int a = 10;      // 第一步
    int b = 20;      // 第二步
    int sum = a + b; // 第三步
    printf("Sum: %d\n", sum); // 第四步
    return 0;        // 第五步
}

选择结构

根据条件判断选择执行不同的代码块。

if-else语句

if-else 语句是最基本的选择结构，用于根据条件表达式的真假执行不同的代码路径。它是程序实现逻辑判断的基础。

1
2
3
4
5
6
7
8
9
if (条件1) {
    // 条件1为真时执行
} else if (条件2) {
    // 条件1为假且条件2为真时执行
} else if (条件3) {
    // 条件1、2为假且条件3为真时执行
} else {
    // 所有条件都为假时执行
}

switch语句

switch 语句是一种多分支选择结构，用于根据表达式的不同值执行不同的代码块。它是if-else if链的替代方案，语法更清晰，执行效率更高。

1
2
3
4
5
6
7
8
9
10
11
12
switch (表达式) {
    case 常量1:
        语句块1;
        break;
    case 常量2:
        语句块2;
        break;
    // 更多case...
    default:
        默认语句块;
        break;
}

条件运算符

条件运算符是C语言中唯一的三目运算符（需要三个操作数），提供了一种简洁的条件选择表达式写法。

执行逻辑：

条件表达式 ? 表达式1 : 表达式2

  • 计算条件表达式
  • 如果条件为真（非0），返回表达式1的值
  • 如果条件为假（0），返回表达式2的值
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
#include <stdio.h>
int main() {
    int a = 10, b = 20, c = 15;
    
    // 嵌套求三个数的最大值
    int max = (a > b) ? 
              ((a > c) ? a : c) : 
              ((b > c) ? b : c);
    
    printf("最大值: %d\n", max);
    
    // 更复杂的例子：成绩等级判断
    int score = 78;
    char* level = (score >= 90) ? "优秀" :
                  (score >= 80) ? "良好" :
                  (score >= 70) ? "中等" :
                  (score >= 60) ? "及格" : "不及格";
    
    printf("成绩等级: %s\n", level);
    return 0;
}

ps: 条件运算符中可以执行表达式

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
#include <stdio.h>

int main() {
    int a = 5, b = 10, c = 15;
    
    // 使用逗号运算符执行多个操作
    int result = (a > b) ? 
                 (printf("a > b, "), a) : 
                 (printf("a <= b, "), b);
    // 输出: "a <= b, "
    // result = 10
    printf("结果: %d\n", result);
    
    // 更复杂的例子
    int max = (a > b) ? 
              ((printf("比较a和c: "), a > c) ? a : c) :
              //如果 a > b 为假：
              // 1. 执行逗号表达式 (printf("比较b和c: "), b > c)
              //    - 先输出"比较b和c: "
              //    - 再计算 b > c，这个结果作为表达式的值 0 (假)或 1(真)
              // 2. 根据 b > c 的结果：
              //    - 如果 b > c 为真，max = b
              //    - 如果 b > c 为假，max = c
              ((printf("比较b和c: "), b > c) ? b : c);
    
    return 0;
}

循环结构

循环结构允许程序重复执行一段代码，直到满足特定条件为止。C语言提供了三种循环结构：

  • while 循环 - 先判断后执行
  • do-while 循环 - 先执行后判断（至少执行一次）
  • for 循环 - 循环次数明确时使用

while循环

执行流程

  • 判断循环条件是否为真（非0）
  • 如果为真，执行循环体
  • 返回步骤1
  • 如果为假，退出循环
1
2
3
4
5
6
7
8
9
10
11
while (循环条件) 
{
    // 循环体：重复执行的代码
}

//无限循环
while (1) {  // 条件永远为真
    printf("无限循环...\n");
    // 通常需要break语句来退出
    // break;
}

do-while 循环

执行流程

  • 先执行循环体一次
  • 判断循环条件是否为真
  • 如果为真，返回步骤1
  • 如果为假，退出循环
1
2
3
4
do 
{
    // 循环体：先执行一次
} while (循环条件);  // 分号不能少

注意: do-while循环至少执行一次!

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
#include <stdio.h>

int main() {
    int i = 10;
    
    do {
        printf("这是do-while循环，i = %d\n", i);
        i++;
    } while (i <= 5);  // 条件初始就不满足
    
    printf("循环结束，i = %d\n", i);
    return 0;
}
//输出：
//这是do-while循环，i = 10
//循环结束，i = 11

for 循环

执行流程

  • 执行初始化表达式（只执行一次）
  • 判断循环条件
  • 如果为真，执行循环体
  • 执行更新表达式
  • 返回步骤2
  • 如果为假，退出循环
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
#include <stdio.h>

int main() {
    // 省略初始化
    int i = 0;
    for (; i < 5; i++) {
        printf("%d ", i);
    }
    printf("\n");
    // 省略所有部分 - 无限循环
    // for (;;) {
    //     printf("无限循环\n");
    // }

    // 多个变量
    for (int i = 1, j = 10; i <= 5; i++, j--) {
        printf("i=%d, j=%d\n", i, j);
    }
    
    return 0;
}

for循环的嵌套

1
2
3
4
5
6
7
for (初始化1; 条件1; 更新1) {      // 外层循环
    // 外层循环体
    for (初始化2; 条件2; 更新2) {  // 内层循环
        // 内层循环体
    }
    // 外层循环体继续
}

打印菱形示例:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
#include <stdio.h>

int main() {
    int n, i, j;
    printf("请输入菱形的大小（上半部分行数）：");
    scanf("%d", &n);
    // 上半部分（包括中间行）
    for (i = 1; i <= n; i++) {
        // 打印空格
        for (j = 1; j <= n - i; j++) {
            printf(" ");
        }
        // 打印星号
        for (j = 1; j <= 2 * i - 1; j++) {
            printf("*");
        }
        printf("\n");
    }
    // 下半部分
    for (i = n - 1; i >= 1; i--) {
        // 打印空格
        for (j = 1; j <= n - i; j++) {
            printf(" ");
        }
        // 打印星号
        for (j = 1; j <= 2 * i - 1; j++) {
            printf("*");
        }
        printf("\n");
    }
    
    return 0;
}
/*当(n=3)输出：
  *
 ***
*****
 ***
  *            */

循环控制语句

循环控制语句用于改变循环的正常执行流程，C语言提供了三种主要的循环控制语句：

  • break - 立即终止当前循环，跳出循环体，执行循环后面的代码。
  • continue - 跳过本次循环的剩余部分，直接开始下一次循环。
  • goto - 无条件跳转到指定标签处。（谨慎使用）
    示例：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
#include <stdio.h>

int main() {
    // break：遇到5立即终止整个for循环

    for (int i = 1; i <= 10; i++) {
        if (i == 5) break; // 触发条件，终止循环
        printf("i = %d\n", i);
    }
    // break示例输出：
    // i = 1
    // i = 2
    // i = 3
    // i = 4

    // continue：跳过偶数，仅执行奇数的打印

    for (int i = 1; i <= 10; i++) {
        if (i % 2 == 0) continue; // 跳过本次循环后续代码，进入下一次循环
        printf("i = %d\n", i);
    }
    // continue示例输出：
    // i = 1
    // i = 3
    // i = 5
    // i = 7
    // i = 9

    // goto：通过标签跳转实现循环（谨慎使用）
    int num = 1;
loop: // 定义循环开始标签
    if (num > 5) goto end; // 满足条件则跳转到结束标签
    printf("num = %d\n", num);
    num++;
    goto loop; // 跳回循环开始标签
end: // 定义循环结束标签
    printf("循环结束\n");
    // num = 1
    // num = 2
    // num = 3
    // num = 4
    // num = 5
    // 循环结束

    return 0;
}
c语言
C语言程序的控制结构
https://linsport.github.io/2025/11/19/c语言编程基础/程序的控制结构/
作者
sport lin
发布于
2025年11月19日
许可协议