C++中的输入与输出
注：初学者只需要掌握cin、cout即可(2.2、3.2小节)
1.C++输入输出概述
C++的输入输出分为两大体系：
1. C++标准输入输出流（IOStream）：以cin（输入流）、cout（输出流）为核心，属于C++原生特性，支持面向对象操作，语法简洁，无需关注数据格式细节，是C++编程中最常用的I/O方式。
2. C语言输入输出函数：以scanf（输入）、printf（输出）为核心，属于C语言标准库（stdio.h），C++完全兼容。其特点是需要手动指定数据格式，执行效率略高，适合对性能有要求或习惯C语言语法的场景。
无论使用哪种方式，都需要包含对应的头文件：使用cin、cout需包含<iostream>头文件；使用scanf、printf需包含<cstdio>（C++推荐）或<stdio.h>（C语言头文件，C++可兼容）。
注意：使用cin、cout时，建议加上
using namespace std;（简化代码，避免重复写std::cin、std::cout）；若不使用，则需全程写完整命名空间（如std::cin >> a;）。2.C++核心输入：cin详解
cin是C++标准输入流对象，隶属于std命名空间，用于从标准输入设备（通常是键盘）读取数据，其核心优势是“自动识别数据类型”，无需手动指定格式，语法简洁，上手容易。
2.1 cin的基本语法
cin使用“提取运算符”>>（右移运算符重载）读取数据，语法格式如下：
cin>>变量1>>变量2>>变量3>>...>>变量n;
说明：
- 提取运算符>>会自动跳过输入中的空白字符（空格、换行、制表符Tab），直到遇到非空白字符才开始读取数据；
- 可以连续使用>>，一次性读取多个不同类型的变量；
- 变量无需初始化，cin读取数据后会自动赋值给变量。
2.2 基本用法示例
以下示例演示cin读取int、float、char、string等常见类型的数据：
#include <iostream>
#include <string> // 读取string类型需包含此头文件
using namespace std;
int main() {
// 1. 读取整数（int）
int a;
cout << "请输入一个整数：";
cin >> a;
// 2. 读取浮点数（float/double）
double b;
cout << "请输入一个浮点数：";
cin >> b;
// 3. 读取单个字符（char）
char c;
cout << "请输入一个字符：";
cin >> c; // 注意：会跳过空白字符，若想读取空格/换行，需特殊处理
// 4. 读取字符串（string）
string str;
cout << "请输入一个字符串（不含空格）：";
cin >> str; // 读取到空白字符（空格、换行）时停止
// 5. 连续读取多个变量
int x, y;
cout << "请输入两个整数（用空格分隔）：";
cin >> x >> y;
// 输出读取到的数据
cout << "你输入的整数：" << a << endl;
cout << "你输入的浮点数：" << b << endl;
cout << "你输入的字符：" << c << endl;
cout << "你输入的字符串：" << str << endl;
cout << "你输入的两个整数：" << x << " " << y << endl;
return 0;
}2.3 cin的关键细节
2.3.1 读取char类型的注意事项
cin >> char变量 会自动跳过输入中的空白字符（空格、换行、Tab），如果需要读取空白字符（比如用户输入的空格、回车），需使用cin.get()函数，示例：
#include <iostream>
using namespace std;
int main() {
char c1, c2;
cout << "请输入两个字符（用空格分隔）：";
cin >> c1; // 读取第一个非空白字符
cin.get(c2); // 读取下一个字符（包括空格、换行）
cout << "c1：" << c1 << "，c2：" << c2 << endl;
return 0;
}输入“a b”，输出结果为“c1：a，c2： ”（c2读取到的是空格），而如果用两次cin >> c2，c2会读取到字符'b'（跳过空格）。
2.3.2 读取string类型的注意事项
cin >> string变量 只能读取“不含空格的字符串”，一旦遇到空格、换行，读取就会停止。如果需要读取包含空格的字符串（比如“Hello World”），需使用getline()函数，示例：
#include <iostream>
#include <string>
using namespace std;
int main() {
string str;
cout << "请输入包含空格的字符串：";
cin.ignore(); // 忽略之前cin留下的换行符（关键！避免getline读取空值）
getline(cin, str); // 读取整行数据，包括空格，直到换行结束
cout << "你输入的字符串：" << str << endl;
return 0;
}注意：如果在getline()之前使用过cin >> 读取数据，cin会在输入缓冲区留下一个“换行符”，getline()会优先读取这个换行符，导致读取失败（看似没输入就结束）。此时需要用cin.ignore()忽略缓冲区中的换行符（或其他多余字符）。
2.3.3 cin的输入失败处理
当输入的数据类型与变量类型不匹配时（比如变量是int，却输入了字母），cin会进入“失败状态”，后续所有cin操作都会失效。此时需要用cin.clear()重置状态，并清空输入缓冲区，示例：
#include <iostream>
using namespace std;
int main() {
int a;
cout << "请输入一个整数：";
cin >> a; // 若输入字母（如abc），cin会失败
// 判断cin是否失败
if (!cin) {
cout << "输入错误！请重新输入一个整数：" << endl;
cin.clear(); // 重置cin状态，使其恢复正常
cin.ignore(1000, '\n'); // 清空缓冲区（忽略最多1000个字符，直到换行）
cin >> a; // 重新读取整数
}
cout << "你输入的整数：" << a << endl;
return 0;
}2.3.4 cin的常用辅助函数
除了基本用法，cin还有几个常用的辅助函数，简化输入操作：
1. cin.get()：读取单个字符（包括空白字符），有两种用法：
- cin.get(char c)：将读取的字符赋值给c；
- char c = cin.get()：直接返回读取的字符。
2. cin.ignore(n, ch)：清空输入缓冲区，忽略最多n个字符，直到遇到字符ch为止（常用cin.ignore(1000, '\n')清空整行缓冲区）。
3. cin.getline(char arr[], int n)：读取字符串到字符数组arr中，最多读取n-1个字符（最后一个字符留作'\0'，表示字符串结束），支持读取包含空格的字符串。
3.C++核心输出：cout详解
cout是C++标准输出流对象，隶属于std命名空间，用于将数据输出到标准输出设备（通常是控制台），与cin对应，同样支持自动识别数据类型，语法简洁，且可通过操纵符灵活控制输出格式（如保留小数、设置对齐方式）。
3.1 cout的基本语法
cout使用“插入运算符”<<（左移运算符重载）输出数据，语法格式如下：
cout << 数据1 << 数据2 << ... << 数据n;
说明：
- 插入运算符<<可以连续使用，一次性输出多个不同类型的数据（如整数、字符串、浮点数）；
- 自动识别数据类型，无需手动指定格式（如输出int和double，会自动区分整数和小数）；
- 可输出常量、变量、表达式（如cout << 1+2 << endl; 输出3）。
3.2 基本用法示例
#include <iostream>
#include <string>
using namespace std;
int main() {
// 1. 输出常量
cout << "Hello C++!" << endl; // 输出字符串常量
cout << 123 << " " << 3.14 << endl; // 输出整数、空格、浮点数
// 2. 输出变量
int a = 10;
double b = 3.14159;
string str = "输入输出详解";
cout << "整数a：" << a << endl;
cout << "浮点数b：" << b << endl;
cout << "字符串str：" << str << endl;
// 3. 输出表达式
cout << "a+5 = " << a+5 << endl;
cout << "b*2 = " << b*2 << endl;
// 4. 连续输出多个数据
cout << "a=" << a << ", b=" << b << ", str=" << str << endl;
return 0;
}3.3 cout的格式控制
cout默认的输出格式可能无法满足需求（如浮点数默认保留6位小数、整数默认右对齐），此时可以使用C++标准库中的“操纵符”（需包含<iomanip>头文件）控制输出格式，常用操纵符如下：
3.3.1 浮点数格式控制
1. fixed：固定小数位数输出（避免科学计数法）；
2. setprecision(n)：设置浮点数的精度（配合fixed使用时，n表示保留n位小数；不配合时，n表示总有效数字位数）；
示例：
#include <iostream>
#include <iomanip> // 格式控制操纵符需包含此头文件
using namespace std;
int main() {
double pi = 3.1415926535;
// 默认输出（保留6位小数，可能用科学计数法）
cout << "默认输出pi：" << pi << endl; // 输出3.141593
// 配合fixed，保留3位小数
cout << "保留3位小数：" << fixed << setprecision(3) << pi << endl; // 输出3.142（四舍五入）
// 不配合fixed，保留5位有效数字
cout << "保留5位有效数字：" << setprecision(5) << pi << endl; // 输出3.1416
return 0;
}3.3.2 整数格式控制
1. dec：十进制输出（默认，可省略）；
2. hex：十六进制输出（字母小写）；
3. oct：八进制输出；
4. setw(n)：设置输出宽度为n个字符，不足补空格（默认右对齐）；
5. left：设置左对齐（配合setw使用）；
示例：
#include <iostream>
#include <iomanip>
using namespace std;
int main() {
int a = 100;
cout << "十进制：" << dec << a << endl; // 输出100（默认）
cout << "十六进制：" << hex << a << endl; // 输出64
cout << "八进制：" << oct << a << endl; // 输出144
// 设置输出宽度为5，默认右对齐
cout << "右对齐（宽度5）：" << setw(5) << a << endl; // 输出 100（前面两个空格）
// 设置左对齐（宽度5）
cout << "左对齐（宽度5）：" << left << setw(5) << a << endl; // 输出100 （后面两个空格）
return 0;
}3.3.3 其他常用格式控制
1. endl：输出一个换行符，并刷新输出缓冲区（确保数据立即显示在控制台）；
2. '\n'：仅输出一个换行符，不刷新缓冲区（效率略高，适合大量输出场景）；
3. setfill(ch)：配合setw使用，设置填充字符（默认填充空格），示例：
#include <iostream>
#include <iomanip>
using namespace std;
int main() {
int a = 100;
// 设置宽度为5，用'*'填充，右对齐
cout << setw(5) << setfill('*') << a << endl; // 输出**100
return 0;
}3.4 cout的关键细节
3.4.1 endl与'\n'的区别
很多初学者会混淆endl和'\n'，两者的核心区别在于“是否刷新缓冲区”：
- endl：输出换行 + 刷新缓冲区（将缓冲区中的数据立即显示到控制台），优点是实时显示，缺点是频繁刷新会降低效率；
- '\n'：仅输出换行，不刷新缓冲区（数据暂时存在缓冲区，积累到一定量再显示），优点是效率高，适合循环输出大量数据的场景。
示例（效率对比）：
#include <iostream>
#include <time.h>
using namespace std;
int main() {
clock_t start, end;
// 用endl输出10000行
start = clock();
for (int i = 0; i < 10000; i++) {
cout << i << endl;
}
end = clock();
cout << "endl耗时：" << end - start << "ms" << endl;
// 用'\n'输出10000行
start = clock();
for (int i = 0; i < 10000; i++) {
cout << i << '\n';
}
end = clock();
cout << "'\\n'耗时：" << end - start << "ms" << endl;
return 0;
}运行结果会显示：用'\n'的耗时远少于endl，尤其是数据量较大时，差异更明显。
3.4.2 格式控制的“持久性”
除了setw(n)（仅对下一次输出有效），其他格式控制操纵符（如fixed、hex、left、setprecision(n)）都是“持久生效”的，直到再次修改格式为止。示例：
#include <iostream>
#include <iomanip>
using namespace std;
int main() {
double a = 3.14, b = 1.2345;
cout << fixed << setprecision(2); // 设置固定小数位，保留2位（持久生效）
cout << a << endl; // 输出3.14
cout << b << endl; // 输出1.23（同样保留2位）
cout << setprecision(3); // 修改为保留3位
cout << b << endl; // 输出1.235
return 0;
}4.C语言输入：scanf详解
scanf是C语言的标准输入函数，C++完全兼容，其核心特点是“需要手动指定输入格式”，执行效率略高于cin，适合对输入效率有要求的场景（如大量数据输入）。但语法相对繁琐，且容易因格式不匹配导致输入错误。
4.1 scanf的基本语法
scanf通过“格式控制字符串”指定输入数据的类型和格式，语法格式如下：
scanf("格式控制字符串", &变量1, &变量2, ..., &变量n);说明：
- 格式控制字符串：用于指定输入数据的类型，必须与后面的变量类型一一对应（否则输入错误）；
- &：取地址符，用于获取变量的内存地址（scanf需要将读取的数据存入变量的内存中，除了字符串数组，其他变量都必须加&）；
- 多个变量之间用逗号分隔，格式控制字符串中可以加入空白字符（空格、换行、Tab），scanf会自动跳过。
4.2 常用格式控制符
scanf的格式控制符必须与变量类型严格对应，常用格式控制符如下：
- %d：读取int类型整数；
- %f：读取float类型浮点数；
- %lf：读取double类型浮点数（重点！新手易混淆，double必须用%lf）；
- %c：读取char类型字符；
- %s：读取字符串（存入字符数组，无需加&）；
- %x：读取十六进制整数；
- %o：读取八进制整数。
4.3 基本用法示例
#include <cstdio> // 使用scanf需包含此头文件
int main() {
// 1. 读取int类型
int a;
printf("请输入一个整数：");
scanf("%d", &a); // 变量a加&，格式控制符%d
// 2. 读取double类型（必须用%lf）
double b;
printf("请输入一个浮点数：");
scanf("%lf", &b);
// 3. 读取char类型
char c;
printf("请输入一个字符：");
scanf("%c", &c); // 会读取空白字符，需注意
// 4. 读取字符串（字符数组）
char str[100]; // 定义字符数组，存储字符串
printf("请输入一个字符串（不含空格）：");
scanf("%s", str); // 字符串数组无需加&
// 5. 连续读取多个变量
int x, y;
printf("请输入两个整数（用空格分隔）：");
scanf("%d %d", &x, &y); // 格式控制符之间加空格（可省略，scanf自动跳过空白）
// 输出验证
printf("你输入的整数a：%d\n", a);
printf("你输入的浮点数b：%.2f\n", b); // 输出时double可用%f
printf("你输入的字符c：%c\n", c);
printf("你输入的字符串str：%s\n", str);
printf("你输入的两个整数x、y：%d %d\n", x, y);
return 0;
}4.4 scanf的关键细节
4.4.1 格式控制符必须严格匹配
这是scanf最容易出错的地方，格式控制符与变量类型不匹配，会导致输入数据错误（或程序异常），常见错误示例：
// 错误1：double类型用了%f
double b;
scanf("%f", &b); // 错误，应使用%lf
// 错误2：int类型用了%lf
int a;
scanf("%lf", &a); // 错误，应使用%d
// 错误3：字符串数组加了&
char str[100];
scanf("%s", &str); // 错误，字符串数组无需加&4.4.2 读取char类型的空白字符问题
scanf("%c", &c) 不会跳过输入中的空白字符（空格、换行、Tab），如果前面有其他输入（如scanf("%d", &a)），输入缓冲区中留下的换行符会被%c读取，导致读取失败。示例及解决方法：
#include <cstdio>
int main() {
int a;
char c;
printf("请输入一个整数和一个字符：");
scanf("%d", &a); // 输入10后按回车，缓冲区留下'\n'
// 解决方法1：在%c前加一个空格（跳过空白字符）
scanf(" %c", &c); // 格式控制符前加空格，跳过所有空白字符
// 解决方法2：用getchar()读取换行符
// getchar();
printf("a=%d, c=%c\n", a, c);
return 0;
}注意：格式控制符前的空格，会让scanf自动跳过所有空白字符（包括换行、空格、Tab），直到遇到非空白字符。
4.4.3 读取字符串的限制
scanf("%s", str) 只能读取不含空格的字符串，遇到空白字符就停止，且不会检查字符数组的长度，如果输入的字符串过长，会导致数组溢出（程序崩溃）。因此，使用时需注意限制输入长度，示例：
char str[10]; // 数组长度为10，最多存储9个字符（最后一个'\0'）
scanf("%9s", str); // 限制读取9个字符，避免溢出5.C语言输出：printf详解
printf是C语言的标准输出函数，C++完全兼容，与scanf对应，需要手动指定输出格式，执行效率略高于cout，格式控制更灵活（尤其是复杂格式输出），但语法相对繁琐，需要记忆格式控制符。
5.1 printf的基本语法
printf通过“格式控制字符串”指定输出数据的类型和格式，语法格式如下：
printf("格式控制字符串", 数据1, 数据2, ..., 数据n);说明：
- 格式控制字符串：包含两部分内容——普通字符（直接输出）和格式控制符（指定数据输出格式）；
- 数据可以是常量、变量、表达式，数量和类型必须与格式控制符一一对应；
- 格式控制符的用法与scanf类似，但有部分差异（如double输出可用%f）。
5.2 常用格式控制符
printf的常用格式控制符，与scanf对应，但需注意差异：
- %d：输出int类型整数；
- %f：输出float、double类型浮点数（重点！double输出可用%f，无需%lf）；
- %c：输出char类型字符；
- %s：输出字符串；
- %x：以十六进制输出整数（字母小写）；
- %X：以十六进制输出整数（字母大写）；
- %o：以八进制输出整数；
- %.nf：输出浮点数，保留n位小数（四舍五入）；
- %nd：输出整数，宽度为n，不足补空格（右对齐）；
- %-nd：输出整数，宽度为n，不足补空格（左对齐）。
5.3 基本用法示例
#include <cstdio>
int main() {
int a = 100;
double b = 3.14159;
char c = 'A';
char str[] = "C++ Input Output";
// 1. 输出整数（基本用法）
printf("整数a（默认）：%d\n", a);
printf("整数a（宽度5，右对齐）：%5d\n", a); // 输出 100
printf("整数a（宽度5，左对齐）：%-5d\n", a); // 输出100
printf("整数a（十六进制）：%x\n", a); // 输出64
printf("整数a（八进制）：%o\n", a); // 输出144
// 2. 输出浮点数
printf("浮点数b（默认）：%f\n", b); // 默认保留6位小数，输出3.141590
printf("浮点数b（保留2位小数）：%.2f\n", b); // 输出3.14
printf("浮点数b（保留4位小数）：%.4f\n", b); // 输出3.1416（四舍五入）
// 3. 输出字符和字符串
printf("字符c：%c\n", c); // 输出A
printf("字符串str：%s\n", str); // 输出C++ Input Output
// 4. 输出表达式
printf("a+5 = %d\n", a+5); // 输出105
printf("b*2 = %.2f\n", b*2); // 输出6.28
// 5. 多个数据同时输出
printf("a=%d, b=%.2f, c=%c\n", a, b, c);
return 0;
}5.4 printf的关键细节
5.4.1 double类型的输出格式
新手容易混淆：scanf读取double用%lf，但printf输出double可用%f（无需%lf），两种写法都正确，但推荐用%f，示例：
double b = 3.14;
printf("%f\n", b); // 正确，输出3.140000
printf("%lf\n", b); // 也正确，同样输出3.140000（C++兼容）5.4.2 类型必须匹配
与scanf类似，printf的格式控制符数量、类型必须与后面的数据一一对应，否则输出乱码或错误，示例：
// 错误1：格式控制符数量少于数据数量
int a=10, b=20;
printf("%d\n", a, b); // 错误，多余的b不会输出，无报错但结果异常
// 错误2：格式控制符类型与数据不匹配
double c=3.14;
printf("%d\n", c); // 错误，输出乱码5.4.3 浮点数的四舍五入
printf的%.nf会对浮点数进行四舍五入处理，示例：
double d1 = 3.14159, d2 = 3.14559;
printf("d1保留2位小数：%.2f\n", d1); // 输出3.14（第四位是1，舍去）
printf("d2保留2位小数：%.2f\n", d2); // 输出3.15（第四位是5，进1）6.四种方式对比总结
为了方便大家选择合适的输入输出方式，整理了四种方式的核心差异、优缺点及适用场景，如下表所示：
6.1 核心对比表
方式 | 类型 | 核心特点 | 优点 | 缺点 | 适用场景 |
|---|---|---|---|---|---|
cin | C++流 | 自动识别类型，无需格式控制 | 语法简洁，上手容易，无需记忆格式符，面向对象 | 执行效率略低，输入失败需手动处理，读取空格/换行需特殊处理 | C++日常编程、初学者入门、数据量不大的场景 |
cout | C++流 | 自动识别类型，可通过操纵符控制格式 | 语法简洁，格式控制灵活（操纵符），可读性强 | 执行效率略低，endl刷新缓冲区影响效率，复杂格式控制不如printf灵活 | C++日常编程、初学者入门、大部分输出场景 |
scanf | C语言函数 | 需手动指定格式控制符，需加取地址符 | 执行效率高，输入大量数据时优势明显，语法紧凑 | 语法繁琐，需记忆格式符，格式不匹配易出错，读取空格/换行需特殊处理 | 大量数据输入、对效率有要求的场景、C/C++兼容编程 |
printf | C语言函数 | 需手动指定格式控制符，格式控制精细 | 执行效率高，格式控制灵活精细，适合复杂输出 | 语法繁琐，需记忆格式符，格式不匹配易输出乱码 | 复杂格式输出、大量数据输出、对效率有要求的场景、C/C++兼容编程 |
6.2 新手建议
1. 初学者入门阶段，优先掌握cin和cout，重点理解其输入输出逻辑、细节（如cin读取空格、cout的endl与'\n'区别），语法简洁，容易上手；
2. 熟练掌握cin和cout后，再学习scanf和printf，重点记忆格式控制符，掌握其与cin、cout的差异，应对效率要求高或复杂格式的场景；
3. C++编程中，可混合使用（如cin输入、printf输出），根据场景灵活选择：日常编程用cin、cout；大量数据或复杂格式用scanf、printf；
4. 无论使用哪种方式，都要注意避坑：cin/cout的输入输出失败、scanf/printf的格式匹配问题。
7.总结
C++中的输入与输出是编程基础，cin和cout作为C++原生的流对象，以“简洁、自动识别类型”为核心优势，是初学者的首选；scanf和printf作为C语言兼容函数，以“高效、格式精细”为特点，适合对性能或格式有要求的场景。
掌握这四种输入输出方式，关键在于理解其核心逻辑、格式控制规则和常见坑点，结合实际场景灵活选择。对于初学者而言，先吃透cin和cout的用法，再逐步拓展到scanf和printf，就能轻松应对大部分C++编程中的输入输出需求。
8.cin和cout常见错误
结合新手高频出错场景，补充cin和cout最常见的错误案例、错误原因及详细解决方案，帮大家避开入门坑，提升编程效率。
8.1 cin常见错误案例及解决方案
案例1：cin读取string后，getline读取空值（高频错误）
错误代码：
#include <iostream>
#include <string>
using namespace std;
int main() {
string name;
string address;
cout << "请输入姓名：";
cin >> name; // 读取姓名（不含空格）
cout << "请输入地址（含空格）：";
getline(cin, address); // 错误：读取到空值，直接跳过输入
cout << "姓名：" << name << "，地址：" << address << endl;
return 0;
}错误原因：cin >> name 读取完姓名后，用户按下的“回车”会作为换行符'\n'留在输入缓冲区，后续getline(cin, address)会优先读取这个'\n'，认为输入已结束，因此读取到空字符串。
解决方案：在getline之前，用cin.ignore()清空缓冲区中的换行符，代码修改如下：
#include <iostream>
#include <string>
using namespace std;
int main() {
string name;
string address;
cout << "请输入姓名：";
cin >> name;
cin.ignore(1000, '\n'); // 关键：清空缓冲区到换行符，忽略换行
cout << "请输入地址（含空格）：";
getline(cin, address); // 正常读取地址
cout << "姓名：" << name << "，地址：" << address << endl;
return 0;
}案例2：cin输入类型不匹配，后续输入全部失效
错误代码：
#include <iostream>
using namespace std;
int main() {
int a, b;
cout << "请输入第一个整数：";
cin >> a; // 若输入字母（如abc），输入类型不匹配
cout << "请输入第二个整数：";
cin >> b; // 错误：后续cin操作失效，无法读取数据
cout << "你输入的两个整数：" << a << " " << b << endl;
return 0;
}错误原因：cin读取数据时，要求输入的数据类型与变量类型严格匹配。当变量为int类型，却输入了字母、符号等非整数数据时，cin会进入“失败状态”（failbit置1），此时cin会停止工作，后续所有cin读取操作都会被跳过，变量值会保持随机的垃圾值，导致程序输出异常。
解决方案：需先通过
!cin判断cin是否处于失败状态，若失败，用cin.clear()重置cin状态（解除失败状态），再用cin.ignore()清空输入缓冲区中的错误数据，最后重新读取正确数据，确保后续cin操作正常执行。修改后代码如下：#include <iostream>
using namespace std;
int main() {
int a, b;
cout << "请输入第一个整数：";
cin >> a; // 若输入非整数，cin进入失败状态
// 判断cin是否失败，若失败则重置并重新读取
if (!cin) {
cout << "输入错误！请重新输入一个整数：" << endl;
cin.clear(); // 重置cin状态，解除失败状态
cin.ignore(1000, '\n'); // 清空缓冲区的错误数据（最多1000个字符，直到换行）
cin >> a; // 重新读取第一个整数
}
// 读取第二个整数（此时cin已恢复正常）
cout << "请输入第二个整数：";
cin >> b;
// 输出验证
cout << "你输入的两个整数：" << a << " " << b << endl;
return 0;
}补充说明：该问题在新手编程中极为常见，尤其在需要连续输入多个数据时。需注意，
cin.clear()仅重置状态，不会清空缓冲区的错误数据，必须配合cin.ignore()使用，否则错误数据会被后续cin继续读取，导致再次失败。若需兼容多次输入错误，可将“判断-重置-重新读取”的逻辑封装为循环，确保读取到正确数据后再继续执行程序。扫描二维码推送至手机访问。
版权声明：本文由青少年编程知识记录发布，如需转载请注明出处。
