智能程序设计（C语言）

/* 三个任务: 不用函数 */
#include <stdio.h>

int main(void)
{
  int m, n, i, d, rev, t;
  int count = 0;

  printf("输入 m n (m<=n): ");
  scanf("%d%d", &m, &n);

  for (i = m; i <= n; i++) {
    /* 任务 1: 输出回文素数 */
    /*   素数检查 (第一次) */
    int is_prime = 1;
    for (d = 2; d <= i / d; d++) {
      if (i % d == 0) {
        is_prime = 0;
        break;
      }
    }
    /*   回文检查 (第一次) */
    t = i; rev = 0;
    while (t > 0) { rev = rev * 10 + t % 10; t = t / 10; }
    if (is_prime && rev == i) {
      printf("%d ", i);
    }

    /* 任务 2: 统计素数个数 */
    /*   素数检查 (第二次, 一字不差) */
    is_prime = 1;
    for (d = 2; d <= i / d; d++) {
      if (i % d == 0) {
        is_prime = 0;
        break;
      }
    }
    if (is_prime) {
      count++;
    }
  }
  printf("\n素数个数: %d\n", count);

  /* 任务 3: 判断 n 是不是回文数 */
  /*   回文检查 (第二次, 一字不差) */
  t = n; rev = 0;
  while (t > 0) { rev = rev * 10 + t % 10; t = t / 10; }
  if (rev == n) {
    printf("%d 是回文数\n", n);
  } else {
    printf("%d 不是回文数\n", n);
  }
  return 0;
}

• 素数检查出现两次、回文检查出现两次——一模一样的代码, 纯复制粘贴

• 三个任务里混着四段检查, main 已经 40 多行, 想看清"程序在干什么"都难

• 素数检查要改 (比如 d * d <= i 优化成 d <= i / d), 两处都要改; 漏改一处, 统计和输出对不上, 结果难以排查

/* 三个任务: 用函数 */
#include <stdio.h>

int is_prime(int n)          /* 素数检查: 写一次 */
{
  int d;

  if (n <= 1) {              /* 1 和 0 不是素数 */
    return 0;
  }
  for (d = 2; d <= n / d; d++) {
    if (n % d == 0) {
      return 0;
    }
  }
  return 1;
}

int is_palindrome(int n)     /* 回文检查: 写一次 */
{
  int rev = 0, t = n;

  while (t > 0) {
    rev = rev * 10 + t % 10;
    t = t / 10;
  }
  return rev == n;
}

int main(void)
{
  int m, n, i, count = 0;

  printf("输入 m n (m<=n): ");
  scanf("%d%d", &m, &n);

  for (i = m; i <= n; i++) {
    /* 任务 1: 输出回文素数 */
    if (is_prime(i) && is_palindrome(i)) {
      printf("%d ", i);
    }
    /* 任务 2: 统计素数个数 */
    if (is_prime(i)) {
      count++;
    }
  }
  printf("\n素数个数: %d\n", count);

  /* 任务 3: 判断 n 是不是回文数 */
  if (is_palindrome(n)) {
    printf("%d 是回文数\n", n);
  } else {
    printf("%d 不是回文数\n", n);
  }
  return 0;
}

• 两道检查各写一遍; is_prime 调用 2×(n-m+1) 次, is_palindrome 只调用素数个数 + 1 次 (&& 短路)——零复制

• main 只剩三个任务的一行行调用, 程序在干什么一目了然

• 检查要改? 只改一处

• if (is_prime(i) && is_palindrome(i)): 函数的返回值可以直接当条件用——这是今天要学的核心玩法

• 顺手补了 n <= 1 守卫: 原版把 1 当素数; 用 1 10 跑一遍会看到行为变化——测试发现旧 bug.

同样的逻辑只写一遍, 需要时调用即可 —— 改 bug 只改一处

程序拆成小块, 更容易调试、理解 —— 每块只做一件事

隐藏实现细节, 只暴露有限、必要的接口

double average(double a, double b)
{
  double sum;       /* declaration */
 
  sum = a + b;      /* statement */
  return sum / 2;   /* statement */
}

每个形式参数前都要说明类型, 参数之间用逗号分隔

没有形式参数时, 括号里写 void

由大括号包围, 里面可以写声明和语句

函数体内声明的变量, 其他函数无法访问或修改

C89: 声明必须写在语句之前; C99: 声明与语句可以混合 (使用前声明过即可)

/* prime.c: 输出 2 ~ 100 的全部素数 */
#include <stdio.h>

int is_prime(int n)
{
  int d;

  if (n <= 1) {            /* 1 和 0 不是素数 */
    return 0;
  }
  for (d = 2; d <= n / d; d++) {
    if (n % d == 0) {
      return 0;
    }
  }
  return 1;
}

int main(void)
{
  int i;

  for (i = 2; i <= 100; i++) {
    if (is_prime(i)) {
      printf("%d ", i);
    }
  }
  printf("\n");
  return 0;
}

• 把 is_prime 的调用放在 if 里, 返回值直接当条件用——非 void 函数的调用就是一个值

• 2 ~ 100 的素数:

2 3 5 7 11 13 17 19 23 29 31 37 41 43 47 53 59 61 67 71 73 79 83 89 97

• 对比之前: 那时要判断一个数, 得把循环抄一遍; 现在写一次, 判断 99 次

练习: 用同样方式写 gcd(a, b)——辗转相除法 (大数除小数取余, 直到余数为 0)

函数没有返回值, 返回类型就写 void:

void print_count(int n)
{
  printf("%d\n", n);
}

没有参数时, 括号里写 void, 调用时也必须写空括号:

void print_line(void)
{
  printf("====\n");
}

void 是一种没有值的类型

print_count 的调用必须自成一个语句: print_count(i);

print_line 的调用: print_line();——括号不能省, 否则编译器把它当成变量

average(x, y)
print_count(i)
print_line()

print_line;   /*** WRONG ***/

print_count(i);
print_line();

avg = average(x, y);
if (average(x, y) > 0) {
  printf("Average is positive\n");
}
printf("The average is %g\n", average(x, y));

函数调用由函数名和用括号括起来的实际参数列表组成:

如果没有括号, 就无法调用函数:

该语句是合法的, 但没有任何作用.

void函数的调用后边始终跟着分号, 使该调用成为语句:

调用非void函数会产生一个值, 该值可存储在变量中或打印等:

average(x, y);  /* discards return value */

num_chars = printf("Hi, Mom!\n");

printf("Hi, Mom!\n"); /* discards return value */

(void) printf("Hi, Mom!\n");

非 void 函数的返回值不需要时, 可以把它丢掉——average(x, y); 就是表达式语句: 算出值, 不保存

printf 返回它打印的字符个数——num_chars = printf("Hi, Mom!\n"); 之后 num_chars 为 9 (可自行验证)

通常我们直接丢弃 printf 的返回值

C 不要求函数的定义在调用之前——可以把 average 的定义放在 main 之后; 但 main 调用它时, 编译器没有任何信息.

• 不报错, 而是假设它返回 int——为该函数创建了隐式声明; 实参个数与类型也无法检查

• 后面遇到真实定义 (返回 double) 才会报错

• 避免方法一: 定义总写在调用之前——可惜有时做不到, 且顺序不自然、难读

计算数字 x 的 n 次幂 \(x^n\):

int power(int x, int n)
{
  int i, result = 1;

  for (i = 1; i <= n; i++) {
    result = result * x;
  }
  return result;   /* x 的 n 次幂 */
}

调用: printf("%d\n", power(2, 5)); → 输出 32

C 里参数是按值传递的:

• 调用函数时, 计算出每个实际参数的值, 并将其赋值给相应的形式参数

• 函数里改形参不影响实参——形参只是实参的副本

按值传递既有优点也有缺点:

• 优点: 形参可以当函数内的普通变量用, 少声明几个变量 (下一页的 power 就这么写)

• 缺点: 想在函数里 "改外面" 的变量, 做不到——下一页的 decompose 就是典型例子

int power(int x, int n)
{
  int result = 1;

  while (n-- > 0) {
    result = result * x;
  }

  return result;
}

void decompose(double x, long int_part, double frac_part)
{
  int_part = (long) x;
  frac_part = x - int_part;
}

decompose(3.14159, i, d);

n 是原始指数的副本, 函数内可以直接修改它 (while (n-- > 0)), 不再需要变量 i

想在函数里 "改外面" 的变量就做不到——decompose 想分解出整数部分和小数部分, 修改形参也没用

decompose(3.14159, i, d) 之后, i、d 纹丝不动

后面的指针部分里, decompose 才能真正奏效 (swap 同理)

double average(double a, double b)
{
  return (a + b) / 2;
}

int main(void)
{
  int x = 3, y = 5;
  printf("%g\n", average(x, y));   /* int 实参 */
  return 0;
}

见过原型 (本页): 每个参数的值被隐式转换为形参的类型, 就像赋值一样

• average(x, y): x、y 是 int, 传给 double 形参时自动转成 double——安全, 结果正确 (输出 4)

没见过原型 (下一页): 执行默认参数提升, 危险——square 的例子

#include <stdio.h>
 
int main(void)
{
  double x = 3.0;
  printf("Square: %d\n", square(x));
 
  return 0;
}
 
int square(int n)
{
  return n * n;
}

printf("Square: %d\n", square((int) x));

• float 实参 → 转 double; char/short 实参 → 转 int (整数提升)

编译器不知道 square 要 int——x 是 double, 提升对它无效, 函数却按 int 解读传入的 double → 结果无效

• 调用前强制转换: square((int) x)

• 更好的办法: 调用前提供原型 (C99 里没声明就调用直接是错误)