实验3

实验任务1
1.源代码

#include <stdio.h>
char score_to_grade(int score);  // 函数声明
int main() {
    int score;
    char grade;
    while (scanf("%d", &score) != EOF) {
        grade = score_to_grade(score);  // 函数调用
        printf("分数: %d, 等级: %c\n\n", score, grade);
    }
    return 0;
}
// 函数定义
char score_to_grade(int score) {
    char ans;
    switch (score / 10) {
    case 10:
    case 9:   ans = 'A'; break;
    case 8:   ans = 'B'; break;
    case 7:   ans = 'C'; break;
    case 6:   ans = 'D'; break;
    default:  ans = 'E';
    }
    return ans;
}

image

问题 1

  • 功能：将输入的整数分数转换为对应的等级字符（90~100→A，80~89→B，70~79→C，60~69→D，<60→E）。
  • 形参类型：int
  • 返回值类型：char
 

问题 2

  1. "A"、"B"等是字符串常量，不能赋值给char类型变量ans，类型不匹配。
  2. 每个case后缺少break，会发生case 穿透，执行后续所有分支。
  3. 原代码case 7、case 6缺少冒号，语法错误。

实验任务2

1.源代码

  
#include <stdio.h>
int sum_digits(int n);  // 函数声明
int main() {
    int n;
    int ans;
    while (printf("Enter n: "), scanf("%d", &n) != EOF) {
        ans = sum_digits(n);    // 函数调用
        printf("n = %d, ans = %d\n\n", n, ans);
    }
    return 0;
}
// 函数定义
int sum_digits(int n) {
    int ans = 0;
    while (n != 0) {
        ans += n % 10;
        n /= 10;
    }
    return ans;
}

2.运行结果

image

问题 1

 
功能：计算一个整数各位数字之和（如 42→4+2=6，2049→2+0+4+9=15）。
 

问题 2

 
  • 能实现相同输出。
  • 区别：原代码是迭代（循环），用while逐位取模累加；改写后是递归，把问题分解为 “个位 + 高位和”，不断调用自身直到 n<10。

实验任务3

1.源代码

  
#include <stdio.h>
int power(int x, int n);    // 函数声明
int main() {
    int x, n;
    int ans;
    while (printf("Enter x and n: "), scanf("%d%d", &x, &n) != EOF) {
        ans = power(x, n);  // 函数调用
        printf("n = %d, ans = %d\n\n", n, ans);
    }

    return 0;
}
// 函数定义
int power(int x, int n) {
    int t;
    if (n == 0)
        return 1;
    else if (n % 2)
        return x * power(x, n - 1);
    else {
        t = power(x, n / 2);
        return t * t;
    }
}

2.运行结果

 

image

问题 1

 
功能：用递归快速幂计算 x 的 n 次方（xⁿ）。
 

问题 2

 
  • 是递归函数。
  • 递归模式：
    1. n=0 → 返回 1
    2. n 为奇数 → x * power (x, n-1)
    3. n 为偶数 → power (x, n/2) 的平方
     image

    实验任务4

     

    1.源代码

      
    #include <stdio.h>
int classify_triangle(int a, int b, int c);

int main() {
    int a, b, c, type;
    while (scanf("%d %d %d", &a, &b, &c) != EOF) {
        type = classify_triangle(a, b, c);
        switch (type) {
        case 0: printf("不能构成三角形\n\n"); break;
        case 1: printf("普通三角形\n\n"); break;
        case 2: printf("等边三角形\n\n"); break;
        case 3: printf("等腰三角形\n\n"); break;
        case 4: printf("直角三角形\n\n"); break;
        }
    }
    return 0;
}

int classify_triangle(int a, int b, int c) {
    if (a + b <= c || a + c <= b || b + c <= a) {
        return 0;
    }
    if (a == b && b == c) {
        return 2;
    }
    if (a == b || b == c || a == c) {
        return 3;
    }
    if (a * a + b * b == c * c || a * a + c * c == b * b || b * b + c * c == a * a) {
        return 4;
    }
    return 1;
}

    2.运行结果

     

    image

    实验任务5

    1.源代码

    迭代
    #include <stdio.h>

int func(int n, int m); 

int main() {
    int n, m;
    int ans;
    while (scanf("%d%d", &n, &m) != EOF) {
        ans = func(n, m); 
        printf("n=%d, m=%d, ans=%d\n\n", n, m, ans);
    }
    return 0;
}

int func(int n, int m) {
    if (m == 0 || n == m) return 1;
    long long ans = 1; 
    for (int i = 1; i <= m; i++) {
        ans = ans * (n - i + 1) / i;
    }
    return (int)ans;
}
    递归
      
    #include <stdio.h>

int func2(int n, int m);
int main() {
    int n, m;
    int ans;
    while (scanf("%d%d", &n, &m) != EOF) {
        ans = func(n, m);
        printf("n=%d, m=%d, ans=%d\n\n", n, m, ans);
    }
    return 0;
}

int func2(int n, int m) {
    if (m == 0 || n == m) {
        return 1;
    }
    if (m > n) {
        return 0; 
    }
    return func(n - 1, m) + func(n - 1, m - 1);
}

    2.运行结果

    迭代
     

    image

    递归
     image

    实验任务6

    1.源代码

      
    #include <stdio.h>

int gcd(int a, int b, int c);

int main() {
    int a, b, c;
    int ans;
    while (scanf("%d%d%d", &a, &b, &c) != EOF) {
        ans = gcd(a, b, c); 
        printf("最大公约数: %d\n\n", ans);
    }
    return 0;
}

int gcd(int a, int b, int c) {
    int min = a;
    if (b < min) min = b;
    if (c < min) min = c;

    for (int i = min; i >= 1; i--) {
        if (a % i == 0 && b % i == 0 && c % i == 0) {
            return i; 
        }
    }
    return 1;
}

    2.运行结果

     

    image

    实验任务7

    1.源代码

      
    #include <stdio.h>
#include <stdlib.h>
void print_charman(int n);
int main() {
    int n;
    printf("Enter n: ");
    while (scanf("%d", &n) != EOF) {
        printf("input n: %d\n", n);
        print_charman(n);  
        printf("\nEnter n: "); 
    }
    return 0;
}

void print_charman(int n) {
    for (int i = 1; i <= n; i++) {
        for (int j = 1; j < i; j++) {
            printf("\t"); 
        }
        for (int j = 1; j <= 2 * (n - i) + 1; j++) {
            printf("  O  \t"); 
        }
        printf("\n");

        for (int j = 1; j < i; j++) {
            printf("\t");
        }
        for (int j = 1; j <= 2 * (n - i) + 1; j++) {
            printf(" <H> \t"); 
        }
        printf("\n");

        for (int j = 1; j < i; j++) {
            printf("\t");
        }
        for (int j = 1; j <= 2 * (n - i) + 1; j++) {
            printf(" I I \t"); 
        }
        printf("\n");
    }
}

    2.运行结果

     

    image

     

    实验感悟

     本次 C 语言函数应用编程实验，围绕函数定义、声明、调用、参数传递、递归与迭代、模块化设计展开，通过 7 个由浅入深的任务，让我系统掌握了函数在程序设计中的核心用法，收获与思考如下：
     

    一、实验核心收获

     
    1. 熟练掌握函数基础用法
       
      明确了函数声明、定义、调用的完整流程，能区分形参与实参，理解值传递的机制，学会按功能拆分代码，让程序结构更清晰、易维护。
       
    2. 理解迭代与递归的区别与适用场景
       
      通过数字求和、组合数计算等任务，对比了两种实现思路：迭代用循环，效率高、无栈溢出风险；递归代码简洁、符合数学逻辑，但需设置明确出口，否则会无限递归。
       
    3. 掌握实用算法与逻辑判断
       
      完成了分数转等级、三角形判断、最大公约数、快速幂、组合数计算等典型案例，学会用switch、分支判断、穷举、分治等方法解决实际问题，提升了逻辑思维与代码调试能力。
       
    4. 解决开发环境常见问题
       
      学会处理 VS 中scanf安全警告、运行窗口闪退、多组输入结束（Ctrl+Z）等实操问题，提升了工程化编程意识。
       
     

    二、实验中遇到的问题与解决

     
    1. 递归函数容易忘记出口，导致程序崩溃，后来通过先写出口、再写递归式的方式避免。
    2. 三角形判断逻辑混乱，未先排序就判断，导致结果错误，修正为先排序再判断边长关系。
    3. 组合数计算时数据溢出，改用long long中间变量提升计算稳定性。

      三、实验思考与改进

       
      1. 函数设计应遵循单一职责原则，一个函数只做一件事，便于复用与调试。
      2. 递归虽简洁，但深度过大时不适用，实际开发优先选择迭代。
      3. 编写代码前应先梳理逻辑、画出流程，减少边写边改带来的错误。
       

      四、总结

       
      本次实验把理论知识转化为实操能力，真正理解了函数是 C 语言模块化编程的核心。后续会继续加强递归、算法优化的练习，养成规范编码、先思考后动手的习惯，提升程序设计的整体能力。
    

    

    

    

    

    

    

    

    • 












            

            
posted @ 
2026-04-19 13:53 
顾伟雲 
阅读(20) 
评论(0) 
 
收藏 
举报