C++ 中 scanf/printf 完全教程

scanf 和 printf 是 C 语言标准库中的输入输出函数，C++ 完全兼容并广泛使用（相比 C++ 的 cin/cout，在性能和格式控制上更有优势）。本教程从基础用法、格式控制、进阶技巧到常见坑点，全面讲解这两个函数的使用。

一、核心概念

• 头文件：必须包含 <cstdio>（C++ 推荐）或 <stdio.h>（兼容 C）。
• 核心作用：
  • scanf：从标准输入（键盘）读取数据，按指定格式解析到变量中。
  • printf：将数据按指定格式输出到标准输出（屏幕）。
• 优势：
  • 速度远快于 cin/cout（尤其处理大量数据时）；
  • 格式控制更精细（如保留小数、对齐、进制转换）。

二、printf 基础用法

1. 基本语法

printf("格式控制字符串", 输出项1, 输出项2, ...);

• 格式控制字符串：包含普通字符（直接输出）和格式说明符（以 % 开头，对应输出项的类型）。
• 输出项：要输出的变量/常量，数量和类型必须与格式说明符一一对应。

2. 常用格式说明符

说明符	对应类型	说明
%d	int	十进制整数
%lld	long long	长整型（64位整数）
%f	float/double	浮点数（默认保留6位小数）
%lf	double	双精度浮点数（等价于%f）
%c	char	单个字符
%s	char*	字符串（以'\0'结尾）
%u	unsigned int	无符号十进制整数
%x/%X	int/unsigned	十六进制整数（小写/大写）
%o		八进制整数
%%	-	输出百分号本身

3. 基础示例

#include <cstdio>
using namespace std;

int main() {
    // 1. 输出整数
    int a = 100;
    printf("整数：%d\n", a); // 输出：整数：100

    // 2. 输出长整型
    long long b = 1234567890123LL;
    printf("长整型：%lld\n", b); // 输出：长整型：1234567890123

    // 3. 输出浮点数
    double c = 3.1415926;
    printf("浮点数默认：%f\n", c); // 输出：浮点数默认：3.141593（自动四舍五入）

    // 4. 输出字符和字符串
    char ch = 'A';
    char str[] = "Hello C++";
    printf("字符：%c，字符串：%s\n", ch, str); // 输出：字符：A，字符串：Hello C++

    // 5. 输出进制
    int d = 255;
    printf("十进制：%d，十六进制：%x，八进制：%o\n", d, d, d); 
    // 输出：十进制：255，十六进制：ff，八进制：377

    // 6. 输出百分号
    printf("百分比：%d%%\n", 80); // 输出：百分比：80%

    return 0;
}

4. 格式精细化控制

（1）浮点数小数位数

语法：%.nf（n 为保留的小数位数）

double pi = 3.1415926535;
printf("保留2位：%.2f\n", pi); // 3.14
printf("保留4位：%.4f\n", pi); // 3.1416

（2）宽度与对齐

语法：%[宽度][对齐]类型

• 宽度：指定输出占的字符数，不足补空格；
• 对齐：- 表示左对齐（默认右对齐）。

int num = 123;
printf("右对齐（宽度5）：%5d\n", num); // 输出：  123（前面补2个空格）
printf("左对齐（宽度5）：%-5d\n", num); // 输出：123  （后面补2个空格）

// 浮点数宽度+小数位
printf("宽度8，保留2位：%8.2f\n", pi); // 输出：   3.14（前面补4个空格）

（3）补零填充

语法：%0[宽度]d（仅对整数有效）

int n = 7;
printf("补零到3位：%03d\n", n); // 输出：007
printf("补零到5位：%05d\n", n); // 输出：00007

三、scanf 基础用法

1. 基本语法

scanf("格式控制字符串", &变量1, &变量2, ...);

• & 取地址符：除字符串（数组名）外，其他变量必须加 &（否则会导致内存错误）；
• 格式说明符：与 printf 基本一致，需匹配变量类型；
• 输入分隔：默认以空格、回车、制表符分隔输入。

2. 常用格式说明符（与 printf 对应）

说明符	对应类型	说明
%d	int	读取十进制整数
%lld	long long	读取长整型
%f	float	读取浮点数
%lf	double	读取双精度浮点数（重点！）
%c	char	读取单个字符（含空白符）
%s	char*	读取字符串（遇空白符停止）
%u	unsigned int	读取无符号整数
%x	int	读取十六进制整数

3. 基础示例

#include <cstdio>
using namespace std;

int main() {
    // 1. 读取整数
    int a;
    printf("输入整数：");
    scanf("%d", &a); // 输入：100 → a=100
    printf("你输入的是：%d\n", a);

    // 2. 读取长整型
    long long b;
    printf("输入长整型：");
    scanf("%lld", &b); // 输入：1234567890123 → b=1234567890123
    printf("你输入的是：%lld\n", b);

    // 3. 读取浮点数（float用%f，double用%lf）
    float f;
    double d;
    printf("输入float和double：");
    scanf("%f %lf", &f, &d); // 输入：3.14 2.71828 → f=3.14, d=2.71828
    printf("float：%f，double：%lf\n", f, d);

    // 4. 读取字符（注意空白符）
    char ch;
    printf("输入字符：");
    getchar(); // 吸收前面的回车（关键！）
    scanf("%c", &ch); // 输入：A → ch='A'
    printf("你输入的是：%c\n", ch);

    // 5. 读取字符串（遇空格停止）
    char str[100];
    printf("输入字符串：");
    scanf("%s", str); // 输入：Hello World → str="Hello"（空格后被截断）
    printf("你输入的是：%s\n", str);

    return 0;
}

4. scanf 进阶技巧

（1）读取带空格的字符串

%s 会被空格截断，需用 fgets 替代（或 scanf 的正则）：

char str[100];
printf("输入带空格的字符串：");
fgets(str, sizeof(str), stdin); // 输入：Hello World → str="Hello World\n"
// 去掉末尾的换行符
str[strcspn(str, "\n")] = '\0';
printf("你输入的是：%s\n", str);

（2）指定输入格式（匹配字符）

例如读取 年-月-日 格式的输入：

int year, month, day;
printf("输入日期（格式：年-月-日）：");
scanf("%d-%d-%d", &year, &month, &day); // 输入：2025-11-30 → year=2025, month=11, day=30
printf("日期：%d年%d月%d日\n", year, month, day);

（3）忽略输入中的指定字符

用 * 跳过某个输入项：

int num;
printf("输入：a123 → 只读取数字：");
scanf("%*c%d", &num); // %*c 跳过第一个字符（a），读取后面的123
printf("读取的数字：%d\n", num); // 输出：123

（4）限制输入长度（防止缓冲区溢出）

语法：%[长度]s

char str[10];
printf("输入字符串（最多9个字符）：");
scanf("%9s", str); // 限制最多读取9个字符（留1位给'\0'）
printf("你输入的是：%s\n", str);

四、scanf/printf 常见坑点

1. 类型不匹配

• long long 必须用 %lld（scanf/printf 都一样），用 %d 会导致数据错误；
• double 在 scanf 中必须用 %lf，printf 中可用 %f 或 %lf（等价）；
• 示例错误：

  long long a;
  scanf("%d", &a); // 错误！应该用%lld
  printf("%d", a); // 错误！应该用%lld
  

2. 忘记加 & 取地址符

除字符串（数组名）外，普通变量必须加 &：

int a;
scanf("%d", a); // 错误！内存崩溃 → 正确：scanf("%d", &a);

3. 字符输入吸收空白符

%c 会读取回车/空格等空白符，导致“跳过输入”：

char ch1, ch2;
scanf("%c", &ch1); // 输入：A → 回车，ch1='A'
scanf("%c", &ch2); // 直接读取回车，ch2='\n'（不是用户输入的字符）

// 解决方法：在%c前加空格，或用getchar()吸收
scanf(" %c", &ch2); // 空格跳过所有空白符
// 或
getchar(); // 吸收回车
scanf("%c", &ch2);

4. 浮点数精度问题

scanf 读取浮点数时，%f 对应 float，%lf 对应 double，混用会导致精度丢失：

double d;
scanf("%f", &d); // 错误！应该用%lf
printf("%.8f\n", d); // 输出错误值

5. 缓冲区溢出

scanf("%s", str) 若输入过长，会超出数组长度，导致内存溢出 → 必须限制长度：

char str[10];
scanf("%9s", str); // 安全：最多读取9个字符

五、scanf/printf vs cin/cout（性能对比）

• 性能：scanf/printf 远快于 cin/cout（尤其处理百万级数据时）；
• 优化 cin/cout：若想用 cin/cout 且提升速度，可加：

  ios::sync_with_stdio(false);
  cin.tie(nullptr);
  

• 场景选择：
  • 算法竞赛/大量数据：优先 scanf/printf；
  • 日常开发：cin/cout 更简洁（无需记忆格式符）。

六、完整示例：综合使用

#include <cstdio>
#include <cstring> // 用于strcspn
using namespace std;

int main() {
    // 输入学生信息：姓名、年龄、成绩（保留1位小数）
    char name[50];
    int age;
    double score;

    printf("请输入学生信息（格式：姓名 年龄 成绩）：\n");
    scanf("%49s %d %lf", name, &age, &score);

    // 格式化输出（左对齐，成绩保留1位小数）
    printf("\n学生信息：\n");
    printf("姓名：%-10s\n", name);  // 左对齐，占10位
    printf("年龄：%3d 岁\n", age);   // 右对齐，占3位
    printf("成绩：%.1f 分\n", score); // 保留1位小数

    // 输入带空格的自我介绍
    char intro[100];
    printf("\n请输入自我介绍（带空格）：\n");
    getchar(); // 吸收前面的回车
    fgets(intro, sizeof(intro), stdin);
    intro[strcspn(intro, "\n")] = '\0'; // 去掉换行符
    printf("自我介绍：%s\n", intro);

    return 0;
}

总结

1. 核心：printf 输出（注意格式符），scanf 输入（注意 & 和类型匹配）；
2. 避坑：long long 用 %lld，double 输入用 %lf，字符输入处理空白符；
3. 性能：大量数据优先 scanf/printf，日常开发可灵活选择。

掌握以上内容，即可熟练使用 scanf/printf 处理 C++ 中的输入输出场景。

下面这份表格以时间为轴，按机械计算萌芽、电子计算机诞生及后续四代计算机的阶段划分，清晰梳理各时期关键节点的核心技术、代表产品和关键人物，方便快速查阅：

时间阶段	关键节点	核心技术	代表产品	关键人物
17世纪 - 20世纪30年代（机械计算萌芽）	1642年	机械齿轮传动实现加减运算	帕斯卡加法器	布莱士·帕斯卡（Blaise Pascal）
	1674年	改进机械结构实现连续运算，提出二进制概念	改进版帕斯卡计算机	戈特弗里德·威廉·莱布尼茨（Gottfried Wilhelm Leibniz）
	1822年	机械结构自动计算多项式函数	差分机	查尔斯·巴贝奇（Charles Babbage）
	1837年	首次提出“存储、运算、控制”核心部件设计，穿孔卡片输入程序	分析机	查尔斯·巴贝奇、埃达·洛夫莱斯（Ada Lovelace，为分析机编写首个程序）
	1890年	穿孔卡片识别技术实现自动数据统计	霍列瑞斯制表机	赫尔曼·霍列瑞斯（Herman Hollerith）
20世纪40年代（电子计算机诞生）	1942年	电子管元件，二进制运算，计算与存储功能分离	ABC计算机	约翰·阿塔纳索夫（John V. Atanasoff）、克利福德·贝瑞（Clifford Berry）
	1943年	电子管结合程序控制，用于密码破译	“巨人”计算机	英国布雷契莱庄园研发团队
	1944年	机械结构与电子元件结合	马克一号	霍华德·艾肯（H. Aiken）
	1946年	大规模电子管集成，实现通用电子计算	ENIAC（电子数字积分计算机）	约翰·莫奇利（J. Mauchiy）、约翰·埃克特（J. Eckert）
1946 - 1958年（第一代：电子管时代）	1949年	存储程序思想，二进制运算，冯·诺依曼架构雏形	EDVAC（电子离散变量自动计算机）	约翰·冯·诺依曼（John von Neumann）、莫奇利、埃克特
	1951年	电子管商用化适配，自动化数据处理	UNIVAC - I（通用自动计算机）	约翰·莫奇利、约翰·埃克特
1958 - 1964年（第二代：晶体管时代）	1958年起	晶体管替代电子管，汇编语言及早期高级语言出现	IBM 7090	IBM研发团队
	1964年前	晶体管优化提升运算速度，适配大规模科学计算	CDC 6600	西摩·克雷（Seymour Cray，CDC公司核心研发者）
1964 - 1971年（第三代：集成电路时代）	1964年	中小规模集成电路集成，分时操作系统技术	IBM System/360系列	IBM研发团队
1971年 - 至今（第四代：超大规模集成电路时代）	1971年	超大规模集成电路集成，微处理器技术	英特尔4004微处理器	英特尔研发团队
	1975年	商用个人计算机架构，组件模块化	Altair 8800	爱德华·罗伯茨（Ed Roberts）
	1976年	简化个人计算机结构，适配民用	Apple I	史蒂夫·乔布斯（Steve Jobs）、史蒂夫·沃兹尼亚克（Steve Wozniak）
	1981年	开放标准PC架构，适配通用操作系统	IBM PC	IBM研发团队、比尔·盖茨（主导适配MS - DOS系统）
	1984年	图形化用户界面技术	苹果Macintosh	史蒂夫·乔布斯、苹果研发团队
	1991年	万维网技术，推动计算机联网共享	互联网雏形设备	蒂姆·伯纳斯 - 李（Tim Berners - Lee）

计算机历史简明教程

核心结论：计算机的发展是“计算需求升级+技术突破”共同驱动的过程，从机械工具逐步演进为电子智能设备，可分为五大关键阶段。

一、史前时代：机械计算的萌芽（17世纪-20世纪30年代）

这一阶段的核心是“用机械结构替代手工计算”，解决海量数据运算的效率问题。

• 1642年，帕斯卡发明“帕斯卡加法器”，是人类首台机械计算器，可自动完成加减运算。
• 1837年，巴贝奇提出“分析机”设计方案，首次包含“存储、运算、控制”三大核心部件，被尊为“计算机技术之父”。
• 19世纪末-20世纪初，打孔卡片机诞生，广泛应用于人口普查等数据统计，成为早期数据存储与处理的重要工具。

---

二、诞生与黎明：电子计算机的出现（20世纪40年代）

二战的军事需求催生了首台电子计算机，标志着“电子计算时代”的开启。

• 1944年，IBM推出“马克一号”，是最后一台大型机械计算机，兼具机械结构与电子元件，为电子计算机奠定基础。
• 1946年，ENIAC（电子数字积分计算机）诞生，是世界首台通用电子计算机，采用电子管作为核心元件，重达30吨，运算速度达每秒5000次加法。
• 核心意义：打破了机械计算的局限，确立了“电子元件”作为计算核心的发展方向。

---

三、第一代计算机：电子管时代（1946-1958年）

核心元件为电子管，计算机体积庞大、能耗高，但实现了从“机械”到“电子”的跨越。

• 技术特征：电子管为核心，使用机器语言编程，无操作系统，存储依赖磁鼓。
• 代表产品：ENIAC、EDVAC（首次实现“存储程序”思想）。
• 应用场景：主要用于军事科研、核物理计算等高端领域，未普及民用。

---

四、第二代计算机：晶体管时代（1958-1964年）

晶体管替代电子管，带来“体积缩小、能耗降低、可靠性提升”的革命性变化。

• 技术特征：晶体管为核心，出现汇编语言和早期高级语言（如FORTRAN、COBOL），开始出现简单操作系统。
• 代表产品：IBM 7090、CDC 6600（当时运算速度最快的计算机）。
• 应用拓展：从军事领域延伸至企业管理、科学计算等，开始进入商用市场。

---

五、第三代计算机：集成电路时代（1964-1971年）

将多个晶体管集成在一块芯片上，计算机向“小型化、系列化、通用化”发展。

• 技术特征：中小规模集成电路为核心，操作系统成熟（如IBM的OS/360），分时操作系统诞生，支持多用户同时使用。
• 代表产品：IBM System/360系列，开创了计算机“兼容机型”的先河。
• 行业变革：计算机开始批量生产，成本大幅下降，应用覆盖政府、金融、教育等多个领域。

---

六、第四代计算机：超大规模集成电路时代（1971年-至今）

超大规模集成电路（VLSI）让芯片集成百万级以上晶体管，催生了个人计算机和互联网革命。

• 技术特征：超大规模集成电路为核心，微处理器诞生，操作系统全面普及（Windows、macOS、Linux），图形界面、多媒体技术逐步成熟。
• 关键节点：1971年英特尔推出4004微处理器，是世界首片微处理器；1981年IBM推出首台个人计算机（PC）；20世纪90年代互联网普及，推动计算机从“单机”走向“联网”。
• 应用现状：计算机全面渗透生活、工作、生产，形成“个人PC+服务器+移动设备”的多元化格局。

---

七、关键人物与里程碑事件

• 冯·诺依曼：提出“存储程序”思想，确立现代计算机的基本架构（运算器、控制器、存储器、输入设备、输出设备）。
• 图灵：提出“图灵测试”，奠定人工智能的理论基础，被称为“人工智能之父”。
• 盖茨与乔布斯：分别推动微软Windows系统和苹果Macintosh计算机普及，加速个人计算机大众化。

好的，我们来详细梳理一下 C++ 中常见运算符的优先级。

运算符的优先级决定了在一个表达式中，各个运算执行的先后顺序。优先级高的运算符会先被执行。

以下是 C++ 中常见运算符的优先级表，从 最高 到 最低 排列。

运算符优先级总表 (由高到低)

优先级	运算符类型	运算符 (示例)	结合性
1	作用域解析	::	左到右
2	后缀运算符	() (函数调用), [] (数组索引), . (成员访问), -> (指针成员访问), ++ (后置自增), -- (后置自减)
3	前缀运算符	++ (前置自增), -- (前置自减), + (正号), - (负号), ! (逻辑非), ~ (按位非), * (解引用), & (取地址), new, delete	右到左
4	乘法/除法/取余	*, /, %	左到右
5	加法/减法	+, -
6	移位运算	<< (左移), >> (右移)
7	关系运算	<, >, <=, >=
8	相等性运算	== (等于), != (不等于)
9	按位与	&
10	按位异或	^
11	按位或	`
12	逻辑与	&&	左到右
13	逻辑或	`
14	三元运算符	condition ? expr1 : expr2	右到左
15	赋值运算符	=, +=, -=, *=, /=, %=, <<=, >>=, &=, ^=, `	=`
16	逗号运算符	,	左到右

---

核心要点说明

1. 结合性 (Associativity)

   • 左到右 (Left-to-Right)：当多个优先级相同的运算符相邻时，从左向右依次执行。例如 a + b - c 等价于 (a + b) - c。
   • 右到左 (Right-to-Left)：当多个优先级相同的运算符相邻时，从右向左依次执行。这种情况相对较少，主要集中在赋值运算符和单目运算符。例如 a = b = c 等价于 a = (b = c)。

2. 括号 () 的作用

   • 括号可以改变运算符的默认优先级。括号内的表达式会被优先计算。
   • 例如，a + b * c 会先算乘法，但 (a + b) * c 会先算加法。在复杂表达式中，善用括号可以让代码意图更清晰，避免因优先级记忆错误导致的 bug。

---

优先级口诀 (帮助记忆)

为了方便记忆，可以参考以下口诀，它覆盖了最常用的运算符：

单目乘除为关系，逻辑三目后赋值。

• 单目：指单目运算符 (!, ~, ++, -- 等)。
• 乘除：指乘法、除法、取余 (*, /, %)。
• 为：这里可以理解为“然后是”。
• 关系：指关系运算符 (<, >, <=, >=, ==, !=)。
• 逻辑：指逻辑运算符 (&&, ||)。
• 三目：指三元运算符 (? :)。
• 赋值：指赋值运算符 (=, +=, 等)。

这个口诀的顺序就是优先级从高到低的顺序。

---

实例分析

让我们通过几个例子来巩固理解：

例 1：算术运算

int x = 6 + 3 * 2; 
// 优先级：* 高于 +
// 等价于：6 + (3 * 2)
// 结果：x = 12

例 2：关系与逻辑运算

bool flag = 5 > 3 && 4 < 1;
// 优先级：> 和 < 高于 &&
// 等价于：(5 > 3) && (4 < 1)
// 结果：flag = true && false = false

例 3：自增与赋值

int a = 5;
int b = ++a * 2; 
// 优先级：++ (前缀) 高于 *
// 等价于：(++a) * 2
// 过程：a先自增为6，然后 6 * 2 = 12
// 结果：b = 12, a = 6

例 4：赋值的结合性

int x, y, z;
x = y = z = 10;
// 优先级：= 是右到左结合
// 等价于：x = (y = (z = 10))
// 结果：x, y, z 的值都为 10

例 5：综合复杂表达式

int a = 3, b = 4, c = 5;
int result = a + b * c - 10 / (b + c);
// 分析：
// 1. 最高优先级：括号内的 b + c = 9
// 2. 然后是 * 和 /：b * c = 20, 10 / 9 = 1 (整数除法)
// 3. 最后是 + 和 -：a + (b*c) = 23, 23 - (10/(b+c)) = 22
// 结果：result = 22

例 6：使用括号改变优先级

int x = (6 + 3) * 2;
// 使用括号后，加法先执行
// 结果：x = 18

理解并熟练掌握运算符的优先级是写出正确、高效的 C++ 代码的基础。在不确定时，查阅此表或使用括号来明确执行顺序总是一个好习惯。

计算机存储容量单位教程

一、基本存储单位

1. 位（bit，比特）

• 定义：是计算机存储的最小单位，只有两种状态，用0和1表示，对应电子元件的“开”和“关”。
• 用途：用于表示二进制数据的最基本单元，例如一个二进制位可以表示一个简单的开关状态、逻辑判断结果等。
• 示例：0、1。

2. 字节（Byte，B）

• 定义：由8个二进制位组成，是计算机存储的基本单位，通常用于表示一个字符（如字母、数字、符号）。
• 换算关系：1 Byte = 8 bit。
• 用途：衡量文件大小、存储数据量等，例如一个英文字母占1字节，一个汉字在UTF-8编码下通常占3字节。
• 示例：存储字母“A”需要1字节，存储数字“5”需要1字节。

二、常用容量单位

1. 千字节（Kilobyte，KB）

• 换算关系：1 KB = 1024 Byte（二进制换算，基于2的10次方），也有部分场景使用1 KB = 1000 Byte（十进制换算，较少见），在计算机领域通常采用二进制换算。
• 用途：用于衡量较小文件的大小，例如一篇简单的纯文本文章可能几KB到几十KB。
• 示例：一首短诗的纯文本文件可能约5KB。

2. 兆字节（Megabyte，MB）

• 换算关系：1 MB = 1024 KB，1 MB = 1024×1024 Byte = 1,048,576 Byte。
• 用途：用于衡量中等大小文件或存储设备的容量，例如一张普通质量的图片约1-5MB，一首MP3格式的歌曲约3-10MB。
• 示例：一部普通画质的电影可能约500MB-1GB。

3. 吉字节（Gigabyte，GB）

• 换算关系：1 GB = 1024 MB，1 GB = 1024×1024×1024 Byte = 1,073,741,824 Byte。
• 用途：用于衡量较大文件、存储设备（如硬盘、U盘）的容量，例如一台计算机的内存可能是8GB、16GB，一个普通硬盘容量可能是500GB、1TB。
• 示例：一部高清电影可能约1-2GB，一个大型游戏可能约20-100GB。

4. 太字节（Terabyte，TB）

• 换算关系：1 TB = 1024 GB。
• 用途：用于衡量大容量存储设备（如服务器硬盘、大型数据中心存储）或大量数据的容量，例如企业级硬盘容量可能达到数TB，大型数据库的数据量可能以TB为单位。
• 示例：一个大型云存储服务商的用户数据总量可能达到数十TB甚至更多。

三、更大容量单位

1. 拍字节（Petabyte，PB）

• 换算关系：1 PB = 1024 TB。
• 用途：用于衡量超大规模数据，例如大型互联网公司的用户数据、全球互联网流量数据等。
• 示例：某大型社交媒体平台的用户生成内容数据量可能达到数PB。

2. 艾字节（Exabyte，EB）

• 换算关系：1 EB = 1024 PB。
• 用途：用于衡量极其庞大的数据，例如全球每年产生的互联网数据量。
• 示例：全球每年的互联网数据流量可能达到数EB。

3. 泽字节（Zettabyte，ZB）、尧字节（Yottabyte，YB）

• 换算关系：1 ZB = 1024 EB，1 YB = 1024 ZB。
• 用途：目前主要用于理论研究和超大规模数据的描述，实际应用中较少见。

四、单位换算总结

单位	换算关系（二进制）	近似十进制换算（仅供参考）
1 KB	$1024$ Byte	$1000$ Byte
1 MB	$1024$ KB = $1,048,576$ Byte	$1,000,000$ Byte
1 GB	$1024$ MB = $1,073,741,824$ Byte	$1,000,000,000$ Byte
1 TB	$1024$ GB	$1,000,000,000,000$ Byte
1 PB	$1024$ TB	-
1 EB	$1024$ PB

五、实际应用注意事项

• 在购买存储设备时，厂商通常采用十进制换算（即1 GB = 1000 MB），而计算机系统中采用二进制换算，因此会出现存储设备标称容量与实际可用容量存在差异的情况。例如，标称1TB的硬盘，实际可用容量约为1000×1000×1000×1000 ÷ (1024×1024×1024) ≈ 931 GB。
• 不同文件类型的存储容量差异很大，例如文本文件通常较小，而视频、图片、大型软件等文件较大。

在C++中，不同数据类型的取值范围由其存储大小和符号属性决定，以下是常见基本数据类型的详细范围说明：

一、整型

类型	字节数	取值范围（有符号）	取值范围（无符号）
short（短整型）	2	$-32768 \sim 32767$（即 $-2^{15} \sim 2^{15}-1$）	$0 \sim 65535$（即 $0 \sim 2^{16}-1$）
int（整型）	4	$-2147483648 \sim 2147483647$（即 $-2^{31} \sim 2^{31}-1$）	$0 \sim 4294967295$（即 $0 \sim 2^{32}-1$）
long（长整型）	4/8（取决于平台）	若为4字节，同int；若为8字节，$-9223372036854775808 \sim 9223372036854775807$（即 $-2^{63} \sim 2^{63}-1$）	若为4字节，同unsigned int；若为8字节，$0 \sim 18446744073709551615$（即 $0 \sim 2^{64}-1$）
long long（长整型）	8	$-9223372036854775808 \sim 9223372036854775807$（即 $-2^{63} \sim 2^{63}-1$）	$0 \sim 18446744073709551615$（即 $0 \sim 2^{64}-1$）

二、浮点型

类型	字节数	精度（有效数字）	取值范围（近似）
float（单精度浮点型）	4	6-7位	最小正非零数约 $1.4013e-45$，最大数约 $3.4028e+38$
double（双精度浮点型）	8	15-16位	最小正非零数约 $4.9407e-324$，最大数约 $1.7977e+308$
long double（扩展精度浮点型）	8/10/16（取决于平台）	18-19位（若为80位实现）	最小正非零数约 $3.3621e-4932$，最大数约 $1.1898e+4932$

三、字符型与布尔型

类型	字节数	取值范围
char（有符号）	1	$-128 \sim 127$
unsigned char（无符号字符）		$0 \sim 255$
bool（布尔型）		仅true（本质为1）和false（本质为0）

注意事项

• 以上范围基于大多数现代编译器和平台的实现，具体可通过<limits>头文件中的常量（如INT_MAX、FLT_MAX等）获取准确值。
• 浮点型存在精度丢失问题，比较时需通过“差值小于极小值”的方式判断，而非直接使用==。
• 无符号类型与有符号类型混合运算时可能发生隐式类型转换，需注意逻辑错误（如负数被转为极大正数）。

C语言一级认证教程

第一章 计算机基础与编程环境

1.1 计算机历史

从第一台电子计算机ENIAC出发，介绍计算机发展的四个阶段：电子管计算机、晶体管计算机、集成电路计算机、大规模集成电路计算机，让学习者了解计算机技术的演进脉络。

1.2 编程环境搭建

详细讲解常见C语言集成开发环境（如Dev-C++、Code::Blocks、Visual Studio）的下载、安装与配置流程，指导学习者创建第一个C语言项目，编写经典的“Hello World”程序并成功编译运行，示例代码如下：

#include <stdio.h>
int main() {
    printf("Hello World!\n");
    return 0;
}

第二章 变量的定义与使用

2.1 变量的概念

变量是计算机内存中用于存储数据的单元，可类比为不同的容器，每个容器有特定的类型和名称，用于存储不同类型的数据。

2.2 变量的定义与初始化

讲解C语言中变量定义的语法，如int a;（定义一个整型变量a），以及初始化的方式，如int b = 10;（定义整型变量b并初始化为10），同时说明变量命名的规则，包括只能由字母、数字和下划线组成，且不能以数字开头等。

第三章 基本数据类型

3.1 整型（int）

用于存储整数，例如年龄、数量等，介绍其在内存中的存储大小（通常为4字节）和取值范围（-2147483648~2147483647），示例：

int age = 20;
int count = 100;

3.2 浮点型（float、double）

用于存储小数，float精度较低（约7位有效数字），double精度较高（约15-17位有效数字），示例：

float pi = 3.14f;
double salary = 5000.5;

3.3 字符型（char）

用于存储单个字符，用单引号括起来，本质是ASCII码值，示例：

char ch = 'A';
char symbol = '#';

第四章 控制语句结构

4.1 顺序结构

程序默认的执行结构，代码按照书写顺序依次执行，通过简单的赋值、输出语句组合案例展示，如：

#include <stdio.h>
int main() {
    int a = 5, b = 3;
    int sum = a + b;
    printf("Sum is %d\n", sum);
    return 0;
}

4.2 选择结构（if-else语句）

• 单分支：if(条件){执行语句;}，示例：

int num = 6;
if (num % 2 == 0) {
    printf("Even number\n");
}

• 双分支：if(条件){执行语句1;}else{执行语句2;}，示例：

int score = 75;
if (score >= 60) {
    printf("Pass\n");
} else {
    printf("Fail\n");
}

• 多分支：if(条件1){执行语句1;}else if(条件2){执行语句2;}else{执行语句3;}，示例：

int grade = 88;
if (grade >= 90) {
    printf("A\n");
} else if (grade >= 80) {
    printf("B\n");
} else if (grade >= 60) {
    printf("C\n");
} else {
    printf("D\n");
}

4.3 循环结构

• for循环：语法为for(初始化表达式;条件表达式;更新表达式){循环体语句;}，用于已知循环次数的场景，如输出1到10的和：

#include <stdio.h>
int main() {
    int sum = 0;
    for (int i = 1; i <= 10; i++) {
        sum += i;
    }
    printf("Sum is %d\n", sum);
    return 0;
}

• while循环：语法为while(条件表达式){循环体语句;}，用于循环次数未知，只要条件满足就循环的场景，如计算1到50的累加和：

#include <stdio.h>
int main() {
    int sum = 0, i = 1;
    while (i <= 50) {
        sum += i;
        i++;
    }
    printf("Sum is %d\n", sum);
    return 0;
}

• do-while循环：语法为do{循环体语句;}while(条件表达式);，与while循环的区别是先执行一次循环体再判断条件，示例：

#include <stdio.h>
int main() {
    int num;
    do {
        printf("Enter a number (0 to exit): ");
        scanf("%d", &num);
        printf("You entered %d\n", num);
    } while (num != 0);
    return 0;
}

第五章 基本运算

5.1 算术运算

讲解加（+）、减（-）、乘（*）、除（/）、取余（%）五种算术运算符，介绍运算优先级，通过计算圆的面积（已知半径）等案例练习，示例：

#include <stdio.h>
#define PI 3.14
int main() {
    float radius = 5.0;
    float area = PI * radius * radius;
    printf("Area of circle is %f\n", area);
    return 0;
}

5.2 关系运算

说明大于（>）、小于（<）、等于（==）、大于等于（>=）、小于等于（<=）、不等于（!=）六种关系运算符，其结果为0（假）或1（真），用于条件判断，如判断两个数是否相等。

5.3 逻辑运算

讲解与（&&）、或（||）、非（!）三种逻辑运算符，结合关系运算构建复杂条件，如(x>0) && (x<10)表示x大于0且小于10。

第六章 输入输出语句

6.1 输出语句（printf）

讲解printf的格式控制符，如%d（整型）、%f（浮点型）、%c（字符型）等，示例：

#include <stdio.h>
int main() {
    int age = 25;
    float height = 1.75;
    char gender = 'M';
    printf("Age: %d, Height: %f, Gender: %c\n", age, height, gender);
    return 0;
}

6.2 输入语句（scanf）

说明scanf的用法，通过&取变量地址来实现输入，示例：

#include <stdio.h>
int main() {
    int num1, num2;
    printf("Enter two numbers: ");
    scanf("%d %d", &num1, &num2);
    int sum = num1 + num2;
    printf("Sum is %d\n", sum);
    return 0;
}

通过本教程的学习，学习者能够掌握C语言一级认证所需的知识，具备使用C语言进行简单程序设计、编译、运行与调试的能力。

C++语言一级认证教程

第一章 计算机基础与编程环境

1.1 计算机历史概述

从1946年ENIAC的诞生讲起，梳理计算机发展的关键阶段：电子管计算机（1946-1958）、晶体管计算机（1958-1964）、集成电路计算机（1964-1971）、大规模集成电路计算机（1971至今）。介绍冯·诺依曼体系结构的核心思想，帮助理解计算机的工作原理。

1.2 编程环境搭建与使用

以Code::Blocks为例，详细讲解下载、安装步骤。指导创建第一个C++项目，编写“Hello World”程序：

#include <iostream>
using namespace std;
int main() {
    cout << "Hello World!" << endl;
    return 0;
}

演示如何编译、运行程序，以及如何查看编译错误并调试。

第二章 变量的定义与使用

2.1 变量的概念

变量是存储数据的内存单元，类比“储物盒”，每个盒子有名称（变量名）、类型（存储数据的种类）、值（存储的具体数据）。

2.2 变量的定义与初始化

• 定义语法：数据类型 变量名;，例如：

  int age;    // 定义整型变量age
  float score; // 定义浮点型变量score
  char gender; // 定义字符型变量gender
  

• 初始化：定义时赋值，例如：

  int age = 15;
  float score = 95.5;
  char gender = 'M';
  

第三章 基本数据类型

3.1 整型（int）

用于存储整数，如人数、年龄等。取值范围约为-21亿到21亿（因编译器而异）。示例：

int studentNum = 45;
int temperature = -5;

3.2 浮点型（float、double）

用于存储小数，float精度较低（约7位有效数字），double精度更高（约15-17位有效数字）。示例：

float pi = 3.14f; // float类型需加后缀f
double salary = 5000.25;

3.3 字符型（char）

用于存储单个字符，用单引号包裹，本质是ASCII码（0-127的整数）。示例：

char grade = 'A';
char symbol = '@';

3.4 布尔型（bool）

仅存储true（真，本质为1）或false（假，本质为0），用于逻辑判断。示例：

bool isAdult = false;
bool hasPassed = true;

第四章 控制语句结构

4.1 顺序结构

程序默认的执行流程，代码按书写顺序依次执行。示例：

#include <iostream>
using namespace std;
int main() {
    int a = 10, b = 20;
    int sum = a + b;
    cout << "Sum is: " << sum << endl;
    return 0;
}

4.2 选择结构（if-else语句）

• 单分支：if(条件){ 执行语句; }

  int num = 5;
  if (num > 0) {
      cout << "Positive number" << endl;
  }
  

• 双分支：if(条件){ 语句1; } else { 语句2; }

  int score = 85;
  if (score >= 60) {
      cout << "Pass" << endl;
  } else {
      cout << "Fail" << endl;
  }
  

• 多分支：if(条件1){ 语句1; } else if(条件2){ 语句2; } ... else { 语句n; }

  int grade = 92;
  if (grade >= 90) {
      cout << "A" << endl;
  } else if (grade >= 80) {
      cout << "B" << endl;
  } else if (grade >= 60) {
      cout << "C" << endl;
  } else {
      cout << "D" << endl;
  }
  

4.3 循环结构

• for循环：for(初始化; 条件; 更新){ 循环体; } 示例：输出1到10的和

  int sum = 0;
  for (int i = 1; i <= 10; i++) {
      sum += i;
  }
  cout << "Sum is: " << sum << endl;
  

• while循环：while(条件){ 循环体; } 示例：计算1到100中偶数的和

  int sum = 0, i = 2;
  while (i <= 100) {
      sum += i;
      i += 2;
  }
  cout << "Sum of even numbers: " << sum << endl;
  

• do-while循环：do{ 循环体; } while(条件);（至少执行一次循环体） 示例：输入数字直到输入0

  int num;
  do {
      cin >> num;
      cout << "You entered: " << num << endl;
  } while (num != 0);
  

第五章 基本运算

5.1 算术运算

• 运算符：+（加）、-（减）、*（乘）、/（除）、%（取余，仅用于整数）
• 示例：

  int a = 10, b = 3;
  cout << "a + b = " << a + b << endl;  // 13
  cout << "a - b = " << a - b << endl;  // 7
  cout << "a * b = " << a * b << endl;  // 30
  cout << "a / b = " << a / b << endl;  // 3（整数除法取整）
  cout << "a % b = " << a % b << endl;  // 1
  

5.2 关系运算

• 运算符：>（大于）、<（小于）、==（等于）、>=（大于等于）、<=（小于等于）、!=（不等于）
• 结果：true（1）或false（0）
• 示例：

  int x = 5, y = 8;
  cout << (x > y) << endl;   // 0（false）
  cout << (x < y) << endl;   // 1（true）
  cout << (x == y) << endl;  // 0（false）
  

5.3 逻辑运算

• 运算符：&&（与，全真则真）、||（或，有真则真）、!（非，取反）
• 示例：

  bool a = true, b = false;
  cout << (a && b) << endl;  // 0（false）
  cout << (a || b) << endl;  // 1（true）
  cout << (!a) << endl;      // 0（false）
  

第六章 输入输出语句

6.1 输出语句（cout）

• 用于在控制台输出数据，需包含头文件<iostream>。
• 示例：

  #include <iostream>
  using namespace std;
  int main() {
      int age = 18;
      string name = "Alice";
      cout << "Name: " << name << ", Age: " << age << endl;
      return 0;
  }
  

6.2 输入语句（cin）

• 用于从键盘读取数据到变量，需包含头文件<iostream>。
• 示例：

  #include <iostream>
  using namespace std;
  int main() {
      int num;
      cout << "Enter a number: ";
      cin >> num;
      cout << "You entered: " << num << endl;
      return 0;
  }
  

实战案例：成绩管理程序

需求：从键盘输入3个学生的成绩，计算平均分，判断是否及格（≥60）。

#include <iostream>
using namespace std;
int main() {
    float score1, score2, score3;
    cout << "Enter score 1: ";
    cin >> score1;
    cout << "Enter score 2: ";
    cin >> score2;
    cout << "Enter score 3: ";
    cin >> score3;
    
    float average = (score1 + score2 + score3) / 3;
    cout << "Average score: " << average << endl;
    
    if (average >= 60) {
        cout << "Pass" << endl;
    } else {
        cout << "Fail" << endl;
    }
    return 0;
}

通过本教程的学习，你将掌握C++一级认证所需的核心知识，能够独立完成简单的程序设计与调试，为后续编程学习打下坚实基础。