活动公告

系统通知
通知：2026夏日主题满意度调查
06-22 18:10
系统通知
通知：微软邮箱更换提醒
06-14 00:00
系统通知
通知：本站资源由网友上传分享，如有违规等问题请到版务模块进行投诉，资源失效请在帖子内回复要求补档，会尽快处理！
10-23 09:31
>社区 > 科技 > 经验交流 >帖子
本版发帖返回

C++输出操作完全手册从基础到进阶学习格式化百分比输出流控制及错误排查解决实际问题提升编程技能实战案例

这是个蓝孩子 当前离线 威震华夏关云长
SunJu_FaceMall

3万

主题

3142

科技点

3万

积分

执行版主

碾压王

积分
32876

塔罗立华奏
执行版主 发表于 2025-9-11 13:10:00 | 显示全部楼层 |阅读模式

马上注册，结交更多好友，享用更多功能，让你轻松玩转社区。

您需要 登录 才可以下载或查看，没有账号？立即注册

x
引言

C++作为一种强大的编程语言，其输入输出系统提供了丰富而灵活的功能。无论是简单的控制台输出，还是复杂的格式化报表，C++的输出机制都能满足各种需求。本手册将全面介绍C++输出操作，从基础概念到进阶技巧，帮助读者掌握格式化输出、百分比输出、流控制以及错误排查等关键技能，并通过实战案例提升编程能力。

C++输出基础

cout对象简介

C++中，cout是ostream类的一个对象，它与标准输出设备（通常是控制台）相关联。cout定义在<iostream>头文件中，是C++标准库的一部分。使用cout进行输出操作前，需要包含相应的头文件：
  2. #include <iostream>
复制代码

基本输出操作

最基本的输出操作使用插入运算符（<<），它将右侧的数据插入到左侧的输出流中：
  2. #include <iostream>
  4. int main() {
  5.     std::cout << "Hello, World!" << std::endl;
  6.     std::cout << 42 << std::endl;
  7.     std::cout << 3.14159 << std::endl;
  8.     return 0;
  9. }
复制代码

在上面的例子中，std::endl是一个操纵符，它输出换行符并刷新输出缓冲区。

输出运算符(<<)的使用

输出运算符（<<）可以被链式使用，连续输出多个项目：
  2. #include <iostream>
  3. #include <string>
  5. int main() {
  6.     std::string name = "Alice";
  7.     int age = 30;
  8.     double height = 1.75;
  9.    
  10.     std::cout << "Name: " << name << ", Age: " << age << ", Height: " << height << "m" << std::endl;
  11.    
  12.     return 0;
  13. }
复制代码

这种链式使用方式非常灵活，可以混合输出不同类型的数据，C++会自动处理类型转换。

格式化输出

使用iomanip库

<iomanip>头文件提供了许多用于格式化输出的操纵符。要使用这些功能，需要包含该头文件：
  2. #include <iomanip>
复制代码

控制输出宽度、精度和填充字符

使用std::setw操纵符可以设置输出的最小宽度：
  2. #include <iostream>
  3. #include <iomanip>
  5. int main() {
  6.     std::cout << "Default width:" << std::endl;
  7.     std::cout << 42 << std::endl;
  8.     std::cout << "Set width to 10:" << std::endl;
  9.     std::cout << std::setw(10) << 42 << std::endl;
  10.     std::cout << "Set width to 10 with '*' as fill character:" << std::endl;
  11.     std::cout << std::setw(10) << std::setfill('*') << 42 << std::endl;
  12.    
  13.     return 0;
  14. }
复制代码

对于浮点数，可以使用std::setprecision操纵符设置精度：
  2. #include <iostream>
  3. #include <iomanip>
  5. int main() {
  6.     double pi = 3.14159265358979323846;
  7.    
  8.     std::cout << "Default precision:" << std::endl;
  9.     std::cout << pi << std::endl;
  10.    
  11.     std::cout << "Set precision to 5:" << std::endl;
  12.     std::cout << std::setprecision(5) << pi << std::endl;
  13.    
  14.     std::cout << "Set precision to 10:" << std::endl;
  15.     std::cout << std::setprecision(10) << pi << std::endl;
  16.    
  17.     return 0;
  18. }
复制代码

使用std::setfill操纵符可以设置填充字符：
  2. #include <iostream>
  3. #include <iomanip>
  5. int main() {
  6.     std::cout << "Default fill:" << std::endl;
  7.     std::cout << std::setw(10) << 42 << std::endl;
  8.    
  9.     std::cout << "Set fill to '*':" << std::endl;
  10.     std::cout << std::setw(10) << std::setfill('*') << 42 << std::endl;
  11.    
  12.     return 0;
  13. }
复制代码

设置进制（十进制、十六进制、八进制）

C++提供了操纵符来控制整数的输出进制：
  2. #include <iostream>
  3. #include <iomanip>
  5. int main() {
  6.     int value = 42;
  7.    
  8.     std::cout << "Decimal: " << std::dec << value << std::endl;
  9.     std::cout << "Hexadecimal: " << std::hex << value << std::endl;
  10.     std::cout << "Octal: " << std::oct << value << std::endl;
  11.    
  12.     // 显示进制前缀
  13.     std::cout << std::showbase;
  14.     std::cout << "Decimal with prefix: " << std::dec << value << std::endl;
  15.     std::cout << "Hexadecimal with prefix: " << std::hex << value << std::endl;
  16.     std::cout << "Octal with prefix: " << std::oct << value << std::endl;
  17.    
  18.     return 0;
  19. }
复制代码

浮点数格式化（科学计数法、定点表示法）

浮点数可以以不同的格式输出：
  2. #include <iostream>
  3. #include <iomanip>
  5. int main() {
  6.     double value = 12345.6789;
  7.    
  8.     // 默认格式
  9.     std::cout << "Default: " << value << std::endl;
  10.    
  11.     // 科学计数法
  12.     std::cout << "Scientific: " << std::scientific << value << std::endl;
  13.    
  14.     // 定点表示法
  15.     std::cout << "Fixed: " << std::fixed << value << std::endl;
  16.    
  17.     // 设置精度
  18.     std::cout << "Fixed with precision 2: " << std::fixed << std::setprecision(2) << value << std::endl;
  19.     std::cout << "Scientific with precision 3: " << std::scientific << std::setprecision(3) << value << std::endl;
  20.    
  21.     return 0;
  22. }
复制代码

百分比输出

百分比输出的基本方法

百分比输出在显示比例、增长率等场景中非常常见。基本方法是将小数值乘以100，然后添加百分号：
  2. #include <iostream>
  4. int main() {
  5.     double ratio = 0.7532;
  6.    
  7.     std::cout << "Basic percentage: " << ratio * 100 << "%" << std::endl;
  8.    
  9.     return 0;
  10. }
复制代码

格式化百分比输出

使用格式化操纵符可以使百分比输出更加美观：
  2. #include <iostream>
  3. #include <iomanip>
  5. int main() {
  6.     double ratio = 0.7532;
  7.    
  8.     std::cout << "Formatted percentage: "
  9.               << std::fixed << std::setprecision(2)
  10.               << ratio * 100 << "%" << std::endl;
  11.    
  12.     // 设置宽度和对齐
  13.     std::cout << "Right-aligned: "
  14.               << std::setw(10) << std::right << std::fixed << std::setprecision(2)
  15.               << ratio * 100 << "%" << std::endl;
  16.    
  17.     std::cout << "Left-aligned: "
  18.               << std::setw(10) << std::left << std::fixed << std::setprecision(2)
  19.               << ratio * 100 << "%" << std::endl;
  20.    
  21.     return 0;
  22. }
复制代码

自定义百分比输出函数

为了更方便地输出百分比，可以创建自定义函数：
  2. #include <iostream>
  3. #include <iomanip>
  4. #include <string>
  6. // 输出百分比，默认精度为2
  7. std::ostream& print_percentage(std::ostream& os, double value, int precision = 2) {
  8.     os << std::fixed << std::setprecision(precision)
  9.        << value * 100 << "%";
  10.     return os;
  11. }
  13. // 输出带宽度的百分比
  14. std::ostream& print_percentage(std::ostream& os, double value, int width, int precision = 2) {
  15.     os << std::fixed << std::setprecision(precision)
  16.        << std::setw(width) << value * 100 << "%";
  17.     return os;
  18. }
  20. int main() {
  21.     double ratio1 = 0.7532;
  22.     double ratio2 = 0.1234;
  23.    
  24.     std::cout << "Custom percentage function: ";
  25.     print_percentage(std::cout, ratio1) << std::endl;
  26.    
  27.     std::cout << "Custom percentage with width and precision: ";
  28.     print_percentage(std::cout, ratio2, 10, 1) << std::endl;
  29.    
  30.     return 0;
  31. }
复制代码

更高级的实现是创建一个操纵符：
  2. #include <iostream>
  3. #include <iomanip>
  4. #include <sstream>
  6. // 百分比操纵符的实现
  7. struct Percentage {
  8.     double value;
  9.     int precision;
  10.     int width;
  11.    
  12.     Percentage(double v, int p = 2, int w = 0) : value(v), precision(p), width(w) {}
  13. };
  15. // 重载<<运算符
  16. std::ostream& operator<<(std::ostream& os, const Percentage& p) {
  17.     std::ostringstream oss;
  18.     oss << std::fixed << std::setprecision(p.precision);
  19.    
  20.     if (p.width > 0) {
  21.         oss << std::setw(p.width);
  22.     }
  23.    
  24.     oss << p.value * 100 << "%";
  25.     os << oss.str();
  26.     return os;
  27. }
  29. // 便捷函数创建Percentage对象
  30. Percentage percentage(double value, int precision = 2, int width = 0) {
  31.     return Percentage(value, precision, width);
  32. }
  34. int main() {
  35.     double ratio1 = 0.7532;
  36.     double ratio2 = 0.1234;
  37.    
  38.     std::cout << "Percentage manipulator: " << percentage(ratio1) << std::endl;
  39.     std::cout << "Percentage with width and precision: " << percentage(ratio2, 1, 10) << std::endl;
  40.    
  41.     return 0;
  42. }
复制代码

输出流控制

流状态标志

C++输出流有一组状态标志，用于控制格式化行为。这些标志可以通过setf和unsetf成员函数进行设置和清除：
  2. #include <iostream>
  3. #include <iomanip>
  5. int main() {
  6.     int value = 42;
  7.    
  8.     // 设置显示进制前缀
  9.     std::cout.setf(std::ios::showbase);
  10.     std::cout << "With showbase: " << std::hex << value << std::endl;
  11.    
  12.     // 清除显示进制前缀
  13.     std::cout.unsetf(std::ios::showbase);
  14.     std::cout << "Without showbase: " << std::hex << value << std::endl;
  15.    
  16.     // 设置显示正号
  17.     std::cout.setf(std::ios::showpos);
  18.     std::cout << "With showpos: " << value << std::endl;
  19.    
  20.     // 清除显示正号
  21.     std::cout.unsetf(std::ios::showpos);
  22.     std::cout << "Without showpos: " << value << std::endl;
  23.    
  24.     return 0;
  25. }
复制代码

常用的流状态标志包括：

• std::ios::boolalpha：以文本格式输出布尔值（true/false）
• std::ios::showbase：显示进制前缀（0x表示十六进制，0表示八进制）
• std::ios::showpoint：显示小数点
• std::ios::showpos：显示正号
• std::ios::skipws：跳过输入中的空白字符
• std::ios::unitbuf：每次输出后刷新缓冲区
• std::ios::uppercase：大写输出（如十六进制的A-F，科学计数法的E）

流操纵符

流操纵符是用于控制输出格式的特殊函数，可以直接插入到输出流中。我们已经见过一些操纵符，如std::endl、std::setw等。下面是一些常用的流操纵符：
  2. #include <iostream>
  3. #include <iomanip>
  5. int main() {
  6.     // 布尔值输出
  7.     bool flag = true;
  8.     std::cout << "Default bool: " << flag << std::endl;
  9.     std::cout << "Boolalpha: " << std::boolalpha << flag << std::endl;
  10.    
  11.     // 对齐方式
  12.     std::cout << "Default alignment: |" << std::setw(10) << 42 << "|" << std::endl;
  13.     std::cout << "Left alignment: |" << std::left << std::setw(10) << 42 << "|" << std::endl;
  14.     std::cout << "Right alignment: |" << std::right << std::setw(10) << 42 << "|" << std::endl;
  15.     std::cout << "Internal alignment: |" << std::internal << std::setw(10) << -42 << "|" << std::endl;
  16.    
  17.     // 大小写控制
  18.     std::cout << "Default hex: " << std::hex << 255 << std::endl;
  19.     std::cout << "Uppercase hex: " << std::uppercase << 255 << std::endl;
  20.     std::cout << "Lowercase hex: " << std::nouppercase << 255 << std::endl;
  21.    
  22.     return 0;
  23. }
复制代码

自定义操纵符

除了使用标准库提供的操纵符外，我们还可以创建自己的操纵符。有两种类型的操纵符：不带参数的和带参数的。
  2. #include <iostream>
  3. #include <iomanip>
  5. // 不带参数的操纵符
  6. std::ostream& add_semicolon(std::ostream& os) {
  7.     os << "; ";
  8.     return os;
  9. }
  11. int main() {
  12.     std::cout << "First item" << add_semicolon
  13.               << "Second item" << add_semicolon
  14.               << "Third item" << std::endl;
  15.    
  16.     return 0;
  17. }
复制代码

创建带参数的操纵符稍微复杂一些，需要使用辅助类和函数：
  2. #include <iostream>
  3. #include <iomanip>
  5. // 辅助类
  6. struct Repeat {
  7.     char c;
  8.     int n;
  9.     Repeat(char ch, int count) : c(ch), n(count) {}
  10. };
  12. // 辅助函数
  13. Repeat repeat(char c, int n) {
  14.     return Repeat(c, n);
  15. }
  17. // 重载<<运算符
  18. std::ostream& operator<<(std::ostream& os, const Repeat& r) {
  19.     for (int i = 0; i < r.n; ++i) {
  20.         os << r.c;
  21.     }
  22.     return os;
  23. }
  25. int main() {
  26.     std::cout << "Header" << std::endl;
  27.     std::cout << repeat('-', 20) << std::endl;
  28.     std::cout << "Content line 1" << std::endl;
  29.     std::cout << "Content line 2" << std::endl;
  30.     std::cout << repeat('=', 20) << std::endl;
  31.    
  32.     return 0;
  33. }
复制代码

输出缓冲区控制

C++输出流通常使用缓冲区来提高性能。缓冲区在以下情况下会被刷新（即内容被实际输出）：

• 缓冲区已满
• 遇到刷新操纵符（如std::endl或std::flush）
• 流被销毁
• 显式调用flush()成员函数
  2. #include <iostream>
  3. #include <chrono>
  4. #include <thread>
  6. int main() {
  7.     // 不带刷新的输出
  8.     std::cout << "This will be buffered";
  9.     std::this_thread::sleep_for(std::chrono::seconds(2));
  10.     std::cout << " and this will appear together with the previous text" << std::endl;
  11.    
  12.     // 带刷新的输出
  13.     std::cout << "This will appear immediately";
  14.     std::cout.flush();  // 显式刷新缓冲区
  15.     std::this_thread::sleep_for(std::chrono::seconds(2));
  16.     std::cout << " and this will appear after 2 seconds" << std::endl;
  17.    
  18.     // 使用endl操纵符（输出换行并刷新）
  19.     std::cout << "This will appear immediately with a newline" << std::endl;
  20.     std::this_thread::sleep_for(std::chrono::seconds(2));
  21.     std::cout << "And this will appear after 2 seconds" << std::endl;
  22.    
  23.     // 使用unitbuf操纵符（每次输出后自动刷新）
  24.     std::cout << std::unitbuf;
  25.     std::cout << "This will appear immediately";
  26.     std::this_thread::sleep_for(std::chrono::seconds(2));
  27.     std::cout << " and this will also appear immediately" << std::endl;
  28.     std::cout << std::nounitbuf;  // 恢复默认缓冲模式
  29.    
  30.     return 0;
  31. }
复制代码

错误排查

常见输出错误及解决方案

问题：输出格式不符合预期，如浮点数精度不正确，对齐方式错误等。

解决方案：检查是否正确使用了格式化操纵符，并注意操纵符的持久性（一些操纵符会影响后续所有输出）。
  2. #include <iostream>
  3. #include <iomanip>
  5. int main() {
  6.     double value = 3.14159265358979323846;
  7.    
  8.     // 错误示例：精度设置会影响后续所有浮点数输出
  9.     std::cout << "Pi with precision 2: " << std::setprecision(2) << value << std::endl;
  10.     std::cout << "Pi with default precision: " << value << std::endl;  // 仍然使用精度2
  11.    
  12.     // 正确示例：保存并恢复流状态
  13.     std::cout << "Pi with precision 2: " << std::setprecision(2) << value << std::endl;
  14.     std::cout << "Pi with restored precision: " << std::setprecision(6) << value << std::endl;
  15.    
  16.     // 更好的方法：使用std::ios_base::precision保存和恢复精度
  17.     std::streamsize original_precision = std::cout.precision();
  18.     std::cout << "Pi with precision 2: " << std::setprecision(2) << value << std::endl;
  19.     std::cout.precision(original_precision);
  20.     std::cout << "Pi with restored precision: " << value << std::endl;
  21.    
  22.     return 0;
  23. }
复制代码

问题：程序崩溃或异常终止时，部分输出没有显示。

解决方案：确保在关键点刷新输出缓冲区，或使用std::unitbuf操纵符实现自动刷新。
  2. #include <iostream>
  3. #include <stdexcept>
  5. void risky_operation() {
  6.     // 模拟可能抛出异常的操作
  7.     throw std::runtime_error("Something went wrong");
  8. }
  10. int main() {
  11.     try {
  12.         std::cout << "Starting risky operation..." << std::flush;  // 确保输出显示
  13.         risky_operation();
  14.         std::cout << "Operation completed successfully." << std::endl;
  15.     } catch (const std::exception& e) {
  16.         std::cout << "Error: " << e.what() << std::endl;
  17.     }
  18.    
  19.     return 0;
  20. }
复制代码

问题：在链式输出中，类型转换可能导致意外结果。

解决方案：使用括号明确表达式的优先级，或避免混合不同类型的输出。
  2. #include <iostream>
  4. int main() {
  5.     int a = 5;
  6.     int b = 10;
  7.    
  8.     // 错误示例：输出可能不符合预期
  9.     std::cout << "a + b = " << a + b << std::endl;  // 实际上输出的是 b，因为 << a + b 等同于 (cout << a) + b
  10.    
  11.     // 正确示例：使用括号明确优先级
  12.     std::cout << "a + b = " << (a + b) << std::endl;
  13.    
  14.     return 0;
  15. }
复制代码

流状态检查

输出流有一个状态标志，用于指示流是否处于良好状态。可以使用以下成员函数检查流状态：

• good()：流是否处于良好状态
• eof()：是否到达输入流的末尾
• fail()：上一次操作是否失败
• bad()：是否发生严重错误
  2. #include <iostream>
  3. #include <fstream>
  5. int main() {
  6.     std::ofstream outfile("test.txt");
  7.    
  8.     if (!outfile) {
  9.         std::cerr << "Failed to open file for writing" << std::endl;
  10.         return 1;
  11.     }
  12.    
  13.     // 检查流状态
  14.     std::cout << "Initial state - good: " << outfile.good()
  15.               << ", fail: " << outfile.fail()
  16.               << ", bad: " << outfile.bad() << std::endl;
  17.    
  18.     outfile << "Hello, World!" << std::endl;
  19.    
  20.     // 再次检查流状态
  21.     std::cout << "After writing - good: " << outfile.good()
  22.               << ", fail: " << outfile.fail()
  23.               << ", bad: " << outfile.bad() << std::endl;
  24.    
  25.     outfile.close();
  26.    
  27.     return 0;
  28. }
复制代码

异常处理

默认情况下，C++流不会抛出异常，而是设置错误状态。可以通过exceptions()成员函数启用异常：
  2. #include <iostream>
  3. #include <fstream>
  5. int main() {
  6.     std::ofstream outfile;
  7.    
  8.     // 启用异常
  9.     outfile.exceptions(std::ofstream::failbit | std::ofstream::badbit);
  10.    
  11.     try {
  12.         outfile.open("nonexistent_directory/test.txt");
  13.         outfile << "Hello, World!" << std::endl;
  14.         outfile.close();
  15.     } catch (const std::ofstream::failure& e) {
  16.         std::cerr << "Exception opening/writing/closing file: " << e.what() << std::endl;
  17.     }
  18.    
  19.     return 0;
  20. }
复制代码

实战案例

案例1：创建格式化报表

假设我们需要创建一个销售报表，包含产品名称、销售数量、单价和总价，并以表格形式输出：
  2. #include <iostream>
  3. #include <iomanip>
  4. #include <vector>
  5. #include <string>
  7. struct Product {
  8.     std::string name;
  9.     int quantity;
  10.     double price;
  11. };
  13. void print_report_header() {
  14.     std::cout << std::setw(20) << std::left << "Product Name"
  15.               << std::setw(10) << std::right << "Quantity"
  16.               << std::setw(12) << "Unit Price"
  17.               << std::setw(12) << "Total Price" << std::endl;
  18.    
  19.     std::cout << std::setw(20) << std::left << std::setfill('-') << ""
  20.               << std::setw(10) << std::right << ""
  21.               << std::setw(12) << ""
  22.               << std::setw(12) << "" << std::endl;
  23.    
  24.     // 恢复填充字符
  25.     std::cout << std::setfill(' ');
  26. }
  28. void print_product(const Product& product) {
  29.     double total = product.quantity * product.price;
  30.    
  31.     std::cout << std::setw(20) << std::left << product.name
  32.               << std::setw(10) << std::right << product.quantity
  33.               << std::setw(12) << std::fixed << std::setprecision(2) << product.price
  34.               << std::setw(12) << std::fixed << std::setprecision(2) << total << std::endl;
  35. }
  37. void print_report_footer(const std::vector<Product>& products) {
  38.     double grand_total = 0.0;
  39.     for (const auto& product : products) {
  40.         grand_total += product.quantity * product.price;
  41.     }
  42.    
  43.     std::cout << std::setw(20) << std::left << std::setfill('-') << ""
  44.               << std::setw(10) << std::right << ""
  45.               << std::setw(12) << ""
  46.               << std::setw(12) << "" << std::endl;
  47.    
  48.     // 恢复填充字符
  49.     std::cout << std::setfill(' ');
  50.    
  51.     std::cout << std::setw(42) << std::right << "Grand Total:"
  52.               << std::setw(12) << std::fixed << std::setprecision(2) << grand_total << std::endl;
  53. }
  55. int main() {
  56.     std::vector<Product> products = {
  57.         {"Laptop", 5, 999.99},
  58.         {"Smartphone", 10, 499.99},
  59.         {"Tablet", 7, 299.99},
  60.         {"Headphones", 15, 79.99},
  61.         {"Smartwatch", 8, 199.99}
  62.     };
  63.    
  64.     std::cout << "SALES REPORT" << std::endl;
  65.     std::cout << "============" << std::endl << std::endl;
  66.    
  67.     print_report_header();
  68.    
  69.     for (const auto& product : products) {
  70.         print_product(product);
  71.     }
  72.    
  73.     print_report_footer(products);
  74.    
  75.     return 0;
  76. }
复制代码

案例2：实现进度条显示

进度条是命令行程序中常见的用户界面元素，用于显示长时间运行操作的进度：
  2. #include <iostream>
  3. #include <iomanip>
  4. #include <chrono>
  5. #include <thread>
  7. class ProgressBar {
  8. private:
  9.     int total;
  10.     int width;
  11.     char complete_char;
  12.     char incomplete_char;
  13.    
  14. public:
  15.     ProgressBar(int total, int width = 50, char complete = '=', char incomplete = ' ')
  16.         : total(total), width(width), complete_char(complete), incomplete_char(incomplete) {}
  17.    
  18.     void display(int progress) {
  19.         float percentage = static_cast<float>(progress) / total;
  20.         int completed_width = static_cast<int>(percentage * width);
  21.         
  22.         std::cout << "\r[";
  23.         std::cout << std::setw(completed_width) << std::setfill(complete_char) << "";
  24.         std::cout << std::setw(width - completed_width) << std::setfill(incomplete_char) << "";
  25.         std::cout << "] " << std::fixed << std::setprecision(1) << percentage * 100 << "%";
  26.         std::cout.flush();
  27.     }
  28.    
  29.     void done() {
  30.         display(total);
  31.         std::cout << std::endl;
  32.     }
  33. };
  35. void simulate_long_task(int steps) {
  36.     ProgressBar bar(steps);
  37.    
  38.     for (int i = 0; i <= steps; ++i) {
  39.         // 模拟工作
  40.         std::this_thread::sleep_for(std::chrono::milliseconds(50));
  41.         
  42.         // 更新进度条
  43.         bar.display(i);
  44.     }
  45.    
  46.     bar.done();
  47. }
  49. int main() {
  50.     std::cout << "Processing data..." << std::endl;
  51.     simulate_long_task(100);
  52.     std::cout << "Task completed!" << std::endl;
  53.    
  54.     return 0;
  55. }
复制代码

案例3：日志系统设计

一个简单的日志系统，支持不同级别的日志输出和时间戳：
  2. #include <iostream>
  3. #include <iomanip>
  4. #include <chrono>
  5. #include <sstream>
  6. #include <string>
  7. #include <fstream>
  9. enum class LogLevel {
  10.     DEBUG,
  11.     INFO,
  12.     WARNING,
  13.     ERROR,
  14.     FATAL
  15. };
  17. class Logger {
  18. private:
  19.     std::ostream& output_stream;
  20.     LogLevel current_level;
  21.     bool show_timestamp;
  22.    
  23.     std::string get_level_string(LogLevel level) {
  24.         switch (level) {
  25.             case LogLevel::DEBUG:   return "DEBUG";
  26.             case LogLevel::INFO:    return "INFO";
  27.             case LogLevel::WARNING: return "WARNING";
  28.             case LogLevel::ERROR:   return "ERROR";
  29.             case LogLevel::FATAL:   return "FATAL";
  30.             default:                return "UNKNOWN";
  31.         }
  32.     }
  33.    
  34.     std::string get_timestamp() {
  35.         auto now = std::chrono::system_clock::now();
  36.         auto time_t = std::chrono::system_clock::to_time_t(now);
  37.         
  38.         std::stringstream ss;
  39.         ss << std::put_time(std::localtime(&time_t), "%Y-%m-%d %H:%M:%S");
  40.         return ss.str();
  41.     }
  42.    
  43. public:
  44.     Logger(std::ostream& stream = std::cout, LogLevel level = LogLevel::INFO, bool timestamp = true)
  45.         : output_stream(stream), current_level(level), show_timestamp(timestamp) {}
  46.    
  47.     void set_level(LogLevel level) {
  48.         current_level = level;
  49.     }
  50.    
  51.     void log(LogLevel level, const std::string& message) {
  52.         if (level >= current_level) {
  53.             if (show_timestamp) {
  54.                 output_stream << "[" << get_timestamp() << "] ";
  55.             }
  56.             
  57.             output_stream << "[" << get_level_string(level) << "] " << message << std::endl;
  58.         }
  59.     }
  60.    
  61.     void debug(const std::string& message) { log(LogLevel::DEBUG, message); }
  62.     void info(const std::string& message) { log(LogLevel::INFO, message); }
  63.     void warning(const std::string& message) { log(LogLevel::WARNING, message); }
  64.     void error(const std::string& message) { log(LogLevel::ERROR, message); }
  65.     void fatal(const std::string& message) { log(LogLevel::FATAL, message); }
  66. };
  68. int main() {
  69.     // 控制台日志
  70.     Logger console_logger;
  71.     console_logger.set_level(LogLevel::DEBUG);
  72.    
  73.     console_logger.debug("This is a debug message");
  74.     console_logger.info("This is an info message");
  75.     console_logger.warning("This is a warning message");
  76.     console_logger.error("This is an error message");
  77.     console_logger.fatal("This is a fatal message");
  78.    
  79.     // 文件日志
  80.     std::ofstream log_file("app.log");
  81.     Logger file_logger(log_file, LogLevel::INFO);
  82.    
  83.     file_logger.info("Application started");
  84.     file_logger.debug("This debug message won't appear in the file");
  85.     file_logger.warning("Something unexpected happened");
  86.     file_logger.info("Application finished");
  87.    
  88.     log_file.close();
  89.    
  90.     return 0;
  91. }
复制代码

进阶技巧

自定义输出运算符重载

通过重载输出运算符（<<），可以为自定义类型提供直接的输出支持：
  2. #include <iostream>
  3. #include <string>
  5. class Person {
  6. private:
  7.     std::string name;
  8.     int age;
  9.     double height;
  10.    
  11. public:
  12.     Person(const std::string& n, int a, double h) : name(n), age(a), height(h) {}
  13.    
  14.     // 声明友元函数以便访问私有成员
  15.     friend std::ostream& operator<<(std::ostream& os, const Person& person);
  16. };
  18. // 重载输出运算符
  19. std::ostream& operator<<(std::ostream& os, const Person& person) {
  20.     os << "Person{name: " << person.name
  21.        << ", age: " << person.age
  22.        << ", height: " << person.height << "m}";
  23.     return os;
  24. }
  26. int main() {
  27.     Person alice("Alice", 30, 1.75);
  28.     Person bob("Bob", 25, 1.82);
  29.    
  30.     std::cout << "Person details:" << std::endl;
  31.     std::cout << alice << std::endl;
  32.     std::cout << bob << std::endl;
  33.    
  34.     return 0;
  35. }
复制代码

国际化输出

C++提供了<locale>头文件来支持国际化输出，包括数字、日期、货币等的本地化格式：
  2. #include <iostream>
  3. #include <iomanip>
  4. #include <locale>
  6. int main() {
  7.     // 设置全局区域
  8.     std::locale::global(std::locale(""));
  9.     std::cout.imbue(std::locale());
  10.    
  11.     double value = 1234567.89;
  12.    
  13.     std::cout << "Default locale: " << value << std::endl;
  14.    
  15.     // 使用特定区域
  16.     std::cout.imbue(std::locale("en_US.UTF-8"));
  17.     std::cout << "US locale: " << value << std::endl;
  18.    
  19.     std::cout.imbue(std::locale("de_DE.UTF-8"));
  20.     std::cout << "German locale: " << value << std::endl;
  21.    
  22.     std::cout.imbue(std::locale("fr_FR.UTF-8"));
  23.     std::cout << "French locale: " << value << std::endl;
  24.    
  25.     // 货币格式化
  26.     std::cout.imbue(std::locale("en_US.UTF-8"));
  27.     std::cout << "US currency: " << std::put_money(value * 100) << std::endl;
  28.    
  29.     std::cout.imbue(std::locale("de_DE.UTF-8"));
  30.     std::cout << "German currency: " << std::put_money(value * 100) << std::endl;
  31.    
  32.     return 0;
  33. }
复制代码

多线程环境下的输出控制

在多线程程序中，直接使用std::cout可能导致输出混乱。可以使用互斥锁来保护输出操作：
  2. #include <iostream>
  3. #include <thread>
  4. #include <vector>
  5. #include <mutex>
  7. // 全局互斥锁保护输出
  8. std::mutex cout_mutex;
  10. void thread_safe_print(const std::string& message) {
  11.     std::lock_guard<std::mutex> lock(cout_mutex);
  12.     std::cout << message << std::endl;
  13. }
  15. void worker(int id) {
  16.     for (int i = 0; i < 5; ++i) {
  17.         thread_safe_print("Thread " + std::to_string(id) + ": message " + std::to_string(i));
  18.         std::this_thread::sleep_for(std::chrono::milliseconds(100));
  19.     }
  20. }
  22. int main() {
  23.     std::vector<std::thread> threads;
  24.    
  25.     // 创建多个线程
  26.     for (int i = 0; i < 5; ++i) {
  27.         threads.emplace_back(worker, i);
  28.     }
  29.    
  30.     // 等待所有线程完成
  31.     for (auto& thread : threads) {
  32.         thread.join();
  33.     }
  34.    
  35.     return 0;
  36. }
复制代码

更高级的实现是创建一个线程安全的日志类：
  2. #include <iostream>
  3. #include <string>
  4. #include <mutex>
  5. #include <chrono>
  6. #include <iomanip>
  7. #include <sstream>
  9. class ThreadSafeLogger {
  10. private:
  11.     std::mutex mtx;
  12.     std::ostream& output_stream;
  13.    
  14.     std::string get_timestamp() {
  15.         auto now = std::chrono::system_clock::now();
  16.         auto time_t = std::chrono::system_clock::to_time_t(now);
  17.         
  18.         std::stringstream ss;
  19.         ss << std::put_time(std::localtime(&time_t), "%Y-%m-%d %H:%M:%S");
  20.         return ss.str();
  21.     }
  22.    
  23. public:
  24.     ThreadSafeLogger(std::ostream& stream = std::cout) : output_stream(stream) {}
  25.    
  26.     void log(const std::string& message) {
  27.         std::lock_guard<std::mutex> lock(mtx);
  28.         output_stream << "[" << get_timestamp() << "] " << message << std::endl;
  29.     }
  30.    
  31.     template<typename T>
  32.     ThreadSafeLogger& operator<<(const T& value) {
  33.         std::lock_guard<std::mutex> lock(mtx);
  34.         output_stream << value;
  35.         return *this;
  36.     }
  37.    
  38.     // 支持操纵符
  39.     ThreadSafeLogger& operator<<(std::ostream& (*manip)(std::ostream&)) {
  40.         std::lock_guard<std::mutex> lock(mtx);
  41.         output_stream << manip;
  42.         return *this;
  43.     }
  44. };
  46. // 全局日志实例
  47. ThreadSafeLogger logger;
  49. void worker(int id) {
  50.     for (int i = 0; i < 5; ++i) {
  51.         logger << "Thread " << id << ": message " << i << std::endl;
  52.         std::this_thread::sleep_for(std::chrono::milliseconds(100));
  53.     }
  54. }
  56. int main() {
  57.     std::vector<std::thread> threads;
  58.    
  59.     // 创建多个线程
  60.     for (int i = 0; i < 5; ++i) {
  61.         threads.emplace_back(worker, i);
  62.     }
  63.    
  64.     // 等待所有线程完成
  65.     for (auto& thread : threads) {
  66.         thread.join();
  67.     }
  68.    
  69.     return 0;
  70. }
复制代码

总结与最佳实践

本手册全面介绍了C++输出操作，从基础的cout使用到高级的格式化、流控制和错误处理。以下是一些关键要点和最佳实践：

1. 格式化输出：使用<iomanip>头文件中的操纵符来控制输出格式，包括宽度、精度、填充字符等。
2. 状态管理：记住许多格式化设置是持久的，会影响后续所有输出。在需要时保存和恢复流状态。
3. 百分比输出：通过将小数值乘以100并添加百分号来实现百分比输出，使用格式化操纵符来控制显示效果。
4. 流控制：理解流状态标志和操纵符的使用，以及如何创建自定义操纵符来简化输出操作。
5. 缓冲区管理：了解输出缓冲区的工作原理，在需要时使用flush()或std::endl来刷新缓冲区。
6. 错误处理：检查流状态，考虑启用异常处理以简化错误处理代码。
7. 实战应用：将所学知识应用于实际问题，如创建格式化报表、进度条和日志系统。
8. 进阶技巧：通过重载输出运算符支持自定义类型的直接输出，使用国际化功能支持多语言环境，以及在多线程程序中安全地进行输出操作。

格式化输出：使用<iomanip>头文件中的操纵符来控制输出格式，包括宽度、精度、填充字符等。

状态管理：记住许多格式化设置是持久的，会影响后续所有输出。在需要时保存和恢复流状态。

百分比输出：通过将小数值乘以100并添加百分号来实现百分比输出，使用格式化操纵符来控制显示效果。

流控制：理解流状态标志和操纵符的使用，以及如何创建自定义操纵符来简化输出操作。

缓冲区管理：了解输出缓冲区的工作原理，在需要时使用flush()或std::endl来刷新缓冲区。

错误处理：检查流状态，考虑启用异常处理以简化错误处理代码。

实战应用：将所学知识应用于实际问题，如创建格式化报表、进度条和日志系统。

进阶技巧：通过重载输出运算符支持自定义类型的直接输出，使用国际化功能支持多语言环境，以及在多线程程序中安全地进行输出操作。

通过掌握这些技能，你将能够更加灵活和高效地处理C++中的输出操作，提升编程技能并解决实际问题。
「七転び八起き（ななころびやおき）」
回复

使用道具 举报

返回列表 发新帖
您需要登录后才可以回帖 登录 | 立即注册
高级模式
B Color Image Link Quote Code Smilies

本版积分规则