智能程序设计（C语言）

#include <stdio.h>

int main(void)
{
  printf("int: %zu 字节\n", sizeof(int));
  printf("char: %zu 字节\n", sizeof(char));
  printf("float: %zu 字节\n", sizeof(float));
  printf("double: %zu 字节\n", sizeof(double));
  return 0;
}

• sizeof 的结果类型是 size_t, 对应占位符 %zu

• 结果随平台变化, 以你机器上的输出为准

• sizeof x 与 sizeof(int) 都可以

• int 的范围限制就来自它只有 4 个字节 (32 位)

• 像 12 小时钟 一样绕圈: 1~12 首尾相接, 12 ≡ 0——"12 + 1 = 1" 其实是 0 + 1; 绕圈只是改名

• 负数用 补码 存: 按位取反再加 1 (如 -1 的位模式全 1); 最高位是符号位 (0 正 1 负); 环上负数在左半圈, 正数在右半圈

• 为什么 5 + (-5) = 0: 5 = 0101, -5 = 1011 (取反加 1); 相加得 1 0000, 丢掉溢出位就是 0000——补码让减法变加法

• 溢出 = 跨过底部分界: 0111 + 1 = 1000 (7 → -8), 反向 -8 - 1 = 7; 顶部 -1 + 1 = 0 回原点; C 不检查溢出

• 同样 32 位, 解释方式不同: int 为 \(-2^{31}\) ~ \(2^{31}-1\) (±21 亿); unsigned 为 \(0\) ~ \(2^{32}-1\) (42 亿)

#include <stdio.h>
#include <limits.h>

int main(void)
{
  printf("INT_MAX     = %d\n", INT_MAX);
  printf("INT_MAX + 1 = %d\n", INT_MAX + 1);

  int n;
  scanf("%d", &n);
  printf("n * 2 = %d\n", n * 2);
  return 0;
}

• INT_MAX + 1 回到 INT_MIN——正好是补码环绕了一圈

• 有符号整数溢出在 C 标准里是未定义行为: 这里只是观察常见实现, 不能依赖

• 输入很大时 n * 2 同样绕圈——实际程序要先判断范围

• 无符号整数溢出是定义良好的 (按 2 的幂取模), 与有符号不同

#include <stdio.h>

int main(void)
{
  int n;
  scanf("%d", &n);

  printf("十进制: %d\n", n);
  printf("八进制: %o\n", n);
  printf("十六进制: %x\n", n);

  printf("0x2a = %d\n", 0x2a);
  printf("052  = %d\n", 052);
  printf("42   = %d\n", 42);
  return 0;
}

• %d / %o / %x 是同一个整数的三种显示方式, 内存里存的值不变

• 0x2a、052、42 都是同一个数 42——前缀只影响源码写法, 不影响值

• 前导 0 是八进制: 010 是 8, 052 是 42; 别把 052 当 52

• 输出十六进制默认小写 (2a); 要大写用 %X (2A)

• 进制只是"面孔": %o / %x 输出都不带前缀

char 存的是编码; 今天把它当整数用

• 'a'=97, 'A'=65, '0'=48, ' '=32——大写字母与小写字母差 32

• 同一个变量, %c 打字符 / %d 打编码

char ch = 'a';
printf("%c  %d\n", ch, ch);   /* a 97 */
printf("%c\n", ch - 32);      /* A */
printf("%d\n", '9' - '0');    /* 9 */

• 常用技巧: toupper/tolower (ctype.h); '9'-'0' 把字符数字变成整数

Hex 列是两位 16 进制; 大写 + 32 = 小写 (如 0x41 + 0x20 = 0x61)

浮点数按 IEEE 754 存: "二进制的科学计数法"——符号 + 指数 + 尾数

• 规范化: 存成 \(1.b_1b_2\cdots \times 2^e\); 开头的 1 必然出现, 隐含不存——白赚一位精度

• 指数用移码存 (float 加 127): 让位模式的顺序与数值顺序一致

• 位数决定精度: float 24 位有效 ≈ 7 位十进制 (保守说 6-7 位); double 53 位 ≈ 16 位 (说 15-16 位)

例: 0.75 怎么存

1. 拆: 0.75 = 0.11₂ = 1.1₂ × 2⁻¹
2. 符号 0; 指数 \(-1 + 127 = 126\), 即 01111110; 尾数 1, 后面补 0 到 23 位 (隐含的 1 不存)
3. 拼起来: 0 01111110 10000000000000000000000
4. 验算: 指数 \(126 - 127 = -1\), 尾数补回 1 得 \(1.1_2\), 即 \(1.1_2 \times 2^{-1} = 0.75\) ✓

特殊值 (选讲): 指数段全 0 / 全 1 保留——全 0 给 ±0 与极小非规格化数, 全 1 给 ±∞ (尾数 0) 或 NaN (尾数非 0)

32 位只有 42.9 亿个图案, 约一半的 float 挤在 -1 到 1 之间——0 附近密, 越远越稀

• 32 位图案只有 2³² ≈ 42.9 亿个, 数轴上的数却无穷多——只能挑出其中有限个"刻度"

• 为什么越远越稀: 浮点 = 固定位数的有效数字 × 2 的指数; 指数每大一级, 相邻刻度的间隔就翻倍

• 1 到 2、2 到 4 各有 \(2^{23}\) ≈ 840 万个 float——区间翻倍, 格子数不变

• 比如 0.1: 落在两个刻度之间, 只能存成最近的刻度——这就是"近似存储"

• 所以比较浮点数不要用 ==, 用 fabs(a - b) < 1e-9 (fabs 是 math.h 的绝对值函数)

0 附近密、越远越稀——刻度间隔随指数翻倍

#include <stdio.h>

int main(void)
{
  double a = 0.1, b = 0.2;
  printf("0.1 + 0.2 = %.17f\n", a + b);
  printf("(0.1 + 0.2) == 0.3 ? %d\n", a + b == 0.3);

  double s = a + a + a;
  printf("0.1 连加三次 = %.17f\n", s);
  printf("s == 0.3 ? %d\n", s == 0.3);
  return 0;
}

• 结果是 0.30000000000000004——浮点是近似存储

• 所以不要用 == 比较浮点数; 判近似相等用 fabs(a - b) < 1e-9

• 为什么存不准? 0.1 落在两个刻度之间, 只能取最近的刻度 (IEEE 754)

• 金额等精确计算常见做法: 放大成整数 (以分为单位)

赋值: 把值存进变量 (height = 8;); 浮点常量float 加 f, double 不加

float profit = 2150.48f;  /* float 加 f */
double pi = 3.14159;      /* double 不加 f */

常量: 值不能改变 (8, 'M'); 符号常量: 给常量起名字, 可读、好改

#define PI 3.14159          /* 宏: 结尾没有分号 */
const double MOL = 6.02E23;  /* const: 只读变量 */

Circle (半径 \(r = 10\))

• 每个结果各占一行

• 小数点后保留两位

样例输出:

circumference = 62.83
area = 314.16

Sphere (半径 \(r = 100\))

• 每个结果占一行, 保留4 位小数

• 每个结果至少占 15 字符, 左对齐

样例输出:

125663.6000     : surface_area
4188786.6667    : volume

#include <stdio.h>
#define PI 3.14159

int main(void)
{
  int r = 10;
  double l = 2 * PI * r;
  double s = PI * r * r;
  printf("circumference = %.2f\n", l);
  printf("area = %.2f\n", s);
  return 0;
}

#include <stdio.h>
#define PI 3.14159

int main(void)
{
  int r = 100;
  double a = 4 * PI * r * r;
  double v = 4.0 / 3 * PI * r * r * r;
  printf("%-15.4f : surface_area\n", a);
  printf("%-15.4f : volume\n", v);
  return 0;
}