初识 C++：format 函数与 cout 输出详解

三、format 函数

1. std::format 核心介绍

std::format 是 C++20 引入的类型安全的字符串格式化工具，核心定位是'统一且优雅的格式化解决方案'，定义在 <format> 头文件中，核心能力包括：

1. 格式化字符串生成：将变量按指定格式拼接成字符串（而非直接输出），再配合 cout/文件等输出；
2. 语法灵活：支持位置占位符、精度控制、对齐、进制转换等；
3. 类型安全：编译期检查类型匹配，避免格式符与变量类型不匹配的运行时错误；
4. 扩展性强：可自定义类/结构体的格式化规则。

基础示例（生成格式化字符串后输出）：

#include <iostream>
#include <format>
using namespace std;
int main() {
    int age = 20;
    double score = 95.567;
    // 生成格式化字符串
    string info = format("年龄：{:>3d}，成绩：{:.2f}", age, score);
    // 配合 cout 输出
    cout << info << endl;
    // 输出：年龄： 20，成绩：95.57
    return 0;
}

2. 核心语法规则（必掌握）

实战示例（组合规则）：

#include <iostream>
#include <format>
using namespace std;
int main() {
    int age = 25;
    double salary = 12345.6789;
    int id = 78;
    // 组合格式化规则：位置 + 补零 + 小数精度
    string info = format(
        "员工 ID：{2:04d} | 年龄：{0:d} | 薪资：{1:+.2f}", age, salary, id
    );
    cout << info << endl;
    // 输出：员工 ID：0078 | 年龄：25 | 薪资：+12345.68
    return 0;
}

3. 三类输入输出方式对比

1. scanf/printf（C 风格）

核心优势：

• 性能极高：直接操作底层缓冲区，无 C++ 流的封装开销，适合高性能场景（如大量数据读写）；
• 兼容性无敌：所有 C/C++ 编译器都支持，无版本限制；
• 格式化紧凑：一行代码可完成复杂格式化（如 printf("%.2f %X", 3.14, 255)）。

核心痛点：

• 类型不安全：比如用 %d 接收 double 类型，编译不报错，运行时崩溃/输出乱码；
• 易出错：格式符与变量数量/类型不匹配、缓冲区溢出（scanf 无边界检查）；
• 不支持自定义类型：无法直接格式化自定义类（如 Point{1,2}）。

2. cin/cout（C++ 流）

核心优势：

• 类型安全：编译期检查类型，比如 cin >> int_var 只能接收整数，否则流状态置错；
• 语法自然：cin >> a >> b、cout << "age: " << age，无需记忆格式符；
• 支持自定义类型：重载 operator>>/operator<< 即可格式化自定义类。

核心痛点：

• 性能差：默认同步 C 标准流（stdio），导致速度比 printf 慢 1-2 个数量级（可通过 ios::sync_with_stdio(false); cin.tie(nullptr); 优化，但仍不如 printf）；
• 格式化繁琐：比如保留 2 位小数需要 cout << fixed << setprecision(2) << score，代码冗长；
• 无占位符灵活度：无法直接调整输出位置、进制（需额外操作）。

3. std::format + cin/cout（C++20）

核心优势（对比前两者的核心提升）：

• 兼顾类型安全与格式化能力：既像 cin/cout 一样编译期检查类型，又像 printf 一样支持复杂格式化，且语法更清晰；
• 格式化语法更优雅：
  • printf：printf("姓名：%s，年龄：%d，成绩：%.2f", name, age, score)；
  • format：format("姓名：{}，年龄：{}，成绩：{:.2f}", name, age, score)；
  • 无需记忆格式符，占位符与变量一一对应，位置可自由调整（如 {1} {0}）；
• 生成字符串而非直接输出：可先格式化字符串（如 string s = format(...)），再按需输出到控制台/文件/网络，灵活性远超 printf/cout；
• 扩展性更强：自定义类型格式化更简洁（重载 formatter），且支持更多格式化场景（如容器、日期）。

核心痛点：

• 仅 C++20+ 支持：低版本编译器（如 GCC 9、MSVC 2019 之前）无法直接使用，需依赖第三方库 fmtlib（format 的前身，语法完全兼容）；
• 性能略低于 printf：但远高于未优化的 cin/cout，且日常开发中性能差异可忽略。

四、cout

一、cout 核心介绍

cout 是 C++ 标准库 <iostream> 中定义的标准输出流对象，全称为 std::cout，核心作用是将数据输出到控制台（终端），是 C++ 替代 C 语言 printf 的面向对象输出方式，核心特点：

• ✅ 类型安全：编译期检查输出数据的类型，避免 printf 的格式符匹配错误；
• ✅ 语法简洁：使用 <<（插入运算符）串联输出内容，无需记忆格式符；
• ✅ 可扩展：支持自定义类型的输出（重载 << 运算符）；
• ❗ 默认性能较低：因同步 C 语言的 stdio 流，可手动优化。

二、cout 基础使用教程

1. 环境准备

只需包含核心头文件 <iostream>，新手可直接使用 using namespace std; 简化代码：

#include <iostream> // 必须包含的头文件
// 可选：避免每次写 std::cout
using namespace std;

2. 核心语法说明

三、cout 格式化输出（重点）

cout 本身格式化能力较弱，需配合 <iomanip> 头文件中的格式化操纵符，实现精度、对齐、进制等控制：

#include <iostream>
#include <iomanip> // 必须包含，提供格式化操纵符
using namespace std;
int main() {
    double pi = 3.1415926;
    int num = 255;
    string str = "abc";
    // 1. 浮点数精度控制（保留 2 位小数）
    cout << "π保留 2 位小数：" << fixed << setprecision(2) << pi << endl;
    // 输出：π保留 2 位小数：3.14
    // 2. 进制转换（十进制/八进制/十六进制）
    cout << "十进制：" << dec << num << endl; // 255
    cout << "八进制：" << oct << num << endl; // 377
    cout << "十六进制：" << hex << uppercase << num << endl; // FF（大写）
    // 3. 对齐与补零（宽度 5，左对齐，补 0）
    cout << "左对齐补 0：" << setw(5) << left << setfill('0') << str << endl;
    // 输出：左对齐补 0：abc00
    // 4. 恢复默认格式
    cout << resetiosflags(ios::fixed | ios::uppercase);
    return 0;
}

核心格式化操纵符（来自 <iomanip>）：

逐类详解：所有格式化场景

1. 浮点数格式化

完整示例：

int main() {
    double pi = 3.141592653589793;
    double num = 1234.5678;
    // 场景 1：默认模式（有效数字，默认 6 位）
    cout << "【默认模式】pi = " << pi << endl; // 输出：3.14159（6 位有效数字）
    cout << "【默认模式】num = " << num << endl; // 输出：1234.57（6 位有效数字，四舍五入）
    // 场景 2：修改有效数字为 4 位（永久生效，直到重置）
    cout << "【有效数字 4 位】pi = " << setprecision(4) << pi << endl; // 3.142（4 位有效数字）
    cout << "【有效数字 4 位】num = " << num << endl; // 1235（4 位有效数字，四舍五入）
    // 场景 3：固定小数位模式（保留 2 位小数）
    cout << "【固定 2 位小数】pi = " << fixed << setprecision(2) << pi << endl; // 3.14
    cout << "【固定 2 位小数】num = " << num << endl; // 1234.57
    // 场景 4：科学计数法（保留 3 位小数）
    cout << "【科学计数法】pi = " << scientific << setprecision(3) << pi << endl; // 3.142e+00
    cout << "【科学计数法】num = " << num << endl; // 1.235e+03
    // 场景 5：重置所有浮点数格式（恢复默认）
    cout << "【重置后】pi = " << resetiosflags(ios::fixed | ios::scientific) << setprecision(6) << pi << endl; // 3.14159（恢复默认 6 位有效数字）
    return 0;
}

2. 整数格式化（对齐、补零、进制）

（1）进制转换（永久生效）

（2）对齐与补位（核心坑点：setw 仅对下一个输出有效）

完整示例（含坑点演示）：

int main() {
    int id = 123;
    int num = 255;
    // 场景 1：学号补零（宽度 5，右对齐，补 0）
    cout << "【学号补零】" << setw(5) << setfill('0') << id << endl; // 00123
    // 坑点：setw 仅对下一个有效，第二次输出 id 不会补零
    cout << "【无 setw】" << id << endl; // 123（无补零）
    // 场景 2：宽度 8，左对齐，补*
    cout << "【左对齐补*】" << setw(8) << left << setfill('*') << id << endl; // 123*****
    // 验证：left 永久生效，下一个输出仍左对齐
    cout << "【左对齐延续】" << setw(8) << num << endl; // 255*****
    // 场景 3：十六进制大写输出
    cout << "【十六进制大写】" << hex << uppercase << num << endl; // FF
    // 恢复十进制 + 默认对齐 + 填充空格
    cout << resetiosflags(ios::uppercase) << dec << right << setfill(' ');
    // 场景 4：宽度不足时不截断（重要）
    cout << "【宽度不足】" << setw(2) << 1234 << endl; // 1234（不会截断为 34）
    return 0;
}

3. 布尔值格式化

示例：

int main() {
    bool flag = true;
    cout << "【默认布尔值】" << flag << endl; // 1
    cout << "【boolalpha】" << boolalpha << flag << endl; // true
    cout << "【恢复默认】" << noboolalpha << flag << endl; // 1
    return 0;
}

4. 字符串格式化（对齐、补位）

字符串格式化逻辑与整数一致，重点注意 setw 仅对下一个字符串生效：

int main() {
    string name = "张三";
    // 宽度 10，右对齐，补-
    cout << "【右对齐补-】" << setw(10) << setfill('-') << name << endl; // --------张三
    // 宽度 10，左对齐，补-
    cout << "【左对齐补-】" << left << setw(10) << name << endl; // 张三--------
    return 0;
}

四、cout 性能优化

cout 默认会同步 C 语言的 printf 缓冲区，导致输出速度比 printf 慢很多，可通过以下两行代码优化（性能接近 printf）：

#include <iostream>
using namespace std;
int main() {
    // 核心优化：关闭 C/C++ 流同步 + 解绑 cin 与 cout
    ios::sync_with_stdio(false);
    cin.tie(nullptr);
    // 大量输出测试（优化后速度提升 10 倍+）
    for (int i = 0; i < 1000000; ++i) {
        cout << i << '\n'; // 用 \n 代替 endl（避免频繁刷新缓冲区）
    }
    return 0;
}

优化关键说明：

1. ios::sync_with_stdio(false)：关闭 cout 与 C 标准输出的同步，减少开销；
2. cin.tie(nullptr)：解绑 cin 和 cout（默认 cin 读取前会刷新 cout 缓冲区）；
3. 用 \n 代替 endl：endl 会强制刷新缓冲区，大量输出时效率极低。

五、cout 扩展：自定义类型输出

通过重载 operator<< 运算符，可让 cout 直接输出自定义类/结构体：

#include <iostream>
#include <string>
using namespace std;
// 自定义结构体：学生
struct Student {
    string name;
    int age;
    double score;
};
// 重载<<运算符（核心步骤）
ostream& operator<<(ostream& os, const Student& stu) {
    // 自定义输出格式
    os << "姓名：" << stu.name << "，年龄：" << stu.age << "，成绩：" << stu.score;
    return os; // 返回 os 以支持链式输出
}
int main() {
    Student s{"张三", 18, 95.5};
    // 直接输出自定义类型
    cout << s << endl; // 输出：姓名：张三，年龄：18，成绩：95.5
    return 0;
}

六、cout 常见问题与解决

1. 问题 1：输出乱码（如中文乱码）
   • 解决：确保控制台编码与源码编码一致（如 UTF-8），Windows 可执行 system("chcp 65001");。
2. 问题 2：setw 仅对下一个输出有效
   • 解决：如需多个输出保持宽度，需重复使用 setw，或先格式化字符串再输出。
3. 问题 3：浮点数输出精度不符合预期
   • 解决：配合 fixed 使用 setprecision，明确指定小数位数。

总结

1. cout 是 C++ 类型安全的标准输出工具，核心语法是 cout << 内容，endl 换行并刷新缓冲区（推荐用 \n 提升性能）；
2. 格式化输出需包含 <iomanip>，使用 setprecision/setw 等操纵符，语法比 printf 繁琐但类型安全；
3. 性能优化关键：关闭 ios::sync_with_stdio(false) + 解绑 cin.tie(nullptr) + 用 \n 代替 endl；
4. 支持自定义类型输出，只需重载 operator<< 运算符。