C++输出编程实战教程从基础语法到高级应用学习标准输出流文件输出和错误处理解决现实编程难题提升开发技能避免常见错误

威震华夏关云长

引言

C++作为一种强大而灵活的编程语言，其输入输出(I/O)系统是程序与外部世界交互的关键。无论是简单的控制台应用程序还是复杂的系统软件，输出功能都扮演着至关重要的角色。本教程将带您从C++输出编程的基础语法开始，逐步深入到高级应用，全面掌握标准输出流、文件输出和错误处理等核心技术。通过本教程的学习，您将能够解决现实编程中的输出难题，提升开发技能，并避免常见的输出编程错误。

C++输出基础：标准输出流

理解输出流概念

在C++中，输出是基于流(stream)的概念实现的。流是一个抽象概念，代表数据的流动。当我们将数据发送到输出设备(如屏幕、文件等)时，我们说数据正在”流出”程序。

C++标准库提供了几个预定义的输出流，最常用的是cout，它与标准输出设备(通常是控制台屏幕)相关联。

基本输出操作

使用cout进行基本输出非常简单，需要包含<iostream>头文件：

2. #include <iostream>
4. int main() {
5.     std::cout << "Hello, World!" << std::endl;
6.     return 0;
7. }

复制代码

在这个例子中：

• std::cout是标准输出流对象
• <<是输出运算符(也称为插入运算符)，它将右侧的数据插入到左侧的流中
• std::endl是一个操纵符(manipulator)，它输出换行符并刷新输出缓冲区

输出不同类型的数据

C++的cout可以自动处理各种基本数据类型：

2. #include <iostream>
4. int main() {
5.     // 输出整数
6.     int age = 25;
7.     std::cout << "Age: " << age << std::endl;
8.    
9.     // 输出浮点数
10.     double price = 19.99;
11.     std::cout << "Price: " << price << std::endl;
12.    
13.     // 输出字符
14.     char grade = 'A';
15.     std::cout << "Grade: " << grade << std::endl;
16.    
17.     // 输出字符串
18.     std::string name = "Alice";
19.     std::cout << "Name: " << name << std::endl;
20.    
21.     // 输出布尔值
22.     bool isStudent = true;
23.     std::cout << "Is student: " << isStudent << std::endl;  // 输出1表示true
24.    
25.     return 0;
26. }

复制代码

链式输出

C++允许使用多个<<运算符将多个输出操作链接在一起，形成链式输出：

2. #include <iostream>
4. int main() {
5.     int x = 10, y = 20;
6.     std::cout << "The sum of " << x << " and " << y << " is " << x + y << std::endl;
7.     return 0;
8. }

复制代码

格式化输出

控制输出宽度

使用std::setw操纵符可以设置输出字段的宽度。需要包含<iomanip>头文件：

2. #include <iostream>
3. #include <iomanip>
5. int main() {
6.     std::cout << "Default:" << std::endl;
7.     std::cout << 123 << std::endl;
8.     std::cout << 45 << std::endl;
9.    
10.     std::cout << "\nWith setw(10):" << std::endl;
11.     std::cout << std::setw(10) << 123 << std::endl;
12.     std::cout << std::setw(10) << 45 << std::endl;
13.    
14.     return 0;
15. }

复制代码

输出结果：

2. Default:
3. 123
4. 45
6. With setw(10):
7.        123
8.         45

复制代码

设置填充字符

默认情况下，当输出宽度大于数据宽度时，多余的位置用空格填充。可以使用std::setfill操纵符更改填充字符：

2. #include <iostream>
3. #include <iomanip>
5. int main() {
6.     std::cout << std::setw(10) << 123 << std::endl;
7.     std::cout << std::setfill('*') << std::setw(10) << 123 << std::endl;
8.     std::cout << std::setfill('0') << std::setw(10) << 123 << std::endl;
9.    
10.     return 0;
11. }

复制代码

输出结果：

2. 123
3. *******123
4. 0000000123

复制代码

控制对齐方式

使用std::left和std::right操纵符可以控制输出在字段中的对齐方式：

2. #include <iostream>
3. #include <iomanip>
5. int main() {
6.     std::cout << "Right alignment (default):" << std::endl;
7.     std::cout << std::setw(10) << "Left" << std::setw(10) << "Right" << std::endl;
8.    
9.     std::cout << "\nLeft alignment:" << std::endl;
10.     std::cout << std::left << std::setw(10) << "Left" << std::setw(10) << "Right" << std::endl;
11.    
12.     return 0;
13. }

复制代码

输出结果：

2. Right alignment (default):
3.       Left     Right
5. Left alignment:
6. Left       Right

复制代码

控制数值格式

对于数值输出，C++提供了多种格式控制选项：

2. #include <iostream>
3. #include <iomanip>
5. int main() {
6.     double pi = 3.14159265358979;
7.    
8.     // 默认浮点数输出
9.     std::cout << "Default: " << pi << std::endl;
10.    
11.     // 设置精度
12.     std::cout << "Precision 5: " << std::setprecision(5) << pi << std::endl;
13.    
14.     // 固定点表示法
15.     std::cout << "Fixed: " << std::fixed << pi << std::endl;
16.    
17.     // 科学计数法
18.     std::cout << "Scientific: " << std::scientific << pi << std::endl;
19.    
20.     // 重置为默认格式
21.     std::cout.unsetf(std::ios_base::floatfield);
22.     std::cout << "Default again: " << pi << std::endl;
23.    
24.     return 0;
25. }

复制代码

输出结果：

2. Default: 3.14159
3. Precision 5: 3.1416
4. Fixed: 3.14159
5. Scientific: 3.141593e+00
6. Default again: 3.14159

复制代码

输出布尔值

默认情况下，bool值输出为1(true)或0(false)。可以使用std::boolalpha操纵符输出文本形式：

2. #include <iostream>
4. int main() {
5.     bool flag = true;
6.    
7.     std::cout << "Default: " << flag << std::endl;
8.     std::cout << "With boolalpha: " << std::boolalpha << flag << std::endl;
9.    
10.     // 切换回数字形式
11.     std::cout << "With noboolalpha: " << std::noboolalpha << flag << std::endl;
12.    
13.     return 0;
14. }

复制代码

输出结果：

2. Default: 1
3. With boolalpha: true
4. With noboolalpha: 1

复制代码

输出整数的进制

可以使用std::dec(十进制)、std::hex(十六进制)和std::oct(八进制)操纵符控制整数的输出进制：

2. #include <iostream>
4. int main() {
5.     int number = 42;
6.    
7.     std::cout << "Decimal: " << std::dec << number << std::endl;
8.     std::cout << "Hexadecimal: " << std::hex << number << std::endl;
9.     std::cout << "Octal: " << std::oct << number << std::endl;
10.    
11.     // 显示进制前缀
12.     std::cout << std::showbase;
13.     std::cout << "Hexadecimal with prefix: " << std::hex << number << std::endl;
14.     std::cout << "Octal with prefix: " << std::oct << number << std::endl;
15.    
16.     return 0;
17. }

复制代码

输出结果：

2. Decimal: 42
3. Hexadecimal: 2a
4. Octal: 52
5. Hexadecimal with prefix: 0x2a
6. Octal with prefix: 052

复制代码

文件输出

基本文件输出

C++中使用ofstream(输出文件流)类进行文件输出操作。需要包含<fstream>头文件：

2. #include <iostream>
3. #include <fstream>
4. #include <string>
6. int main() {
7.     // 创建输出文件流对象
8.     std::ofstream outFile("example.txt");
9.    
10.     // 检查文件是否成功打开
11.     if (!outFile) {
12.         std::cerr << "Error: Could not open file for writing." << std::endl;
13.         return 1;
14.     }
15.    
16.     // 写入文件
17.     outFile << "Hello, File!" << std::endl;
18.     outFile << "This is a line of text." << std::endl;
19.    
20.     // 关闭文件
21.     outFile.close();
22.    
23.     std::cout << "Data written to file successfully." << std::endl;
24.    
25.     return 0;
26. }

复制代码

文件打开模式

ofstream的构造函数或open()方法可以接受第二个参数，指定文件的打开模式：

2. #include <iostream>
3. #include <fstream>
5. int main() {
6.     // 输出模式(默认)
7.     std::ofstream outFile1("example1.txt", std::ios::out);
8.    
9.     // 追加模式
10.     std::ofstream outFile2("example2.txt", std::ios::app);
11.    
12.     // 二进制模式
13.     std::ofstream outFile3("example3.dat", std::ios::binary);
14.    
15.     // 组合模式：追加和二进制
16.     std::ofstream outFile4("example4.dat", std::ios::app | std::ios::binary);
17.    
18.     // 检查文件是否成功打开
19.     if (!outFile1 || !outFile2 || !outFile3 || !outFile4) {
20.         std::cerr << "Error: Could not open one or more files." << std::endl;
21.         return 1;
22.     }
23.    
24.     // 写入数据
25.     outFile1 << "This is output mode." << std::endl;
26.     outFile2 << "This is append mode." << std::endl;
27.    
28.     // 关闭文件
29.     outFile1.close();
30.     outFile2.close();
31.     outFile3.close();
32.     outFile4.close();
33.    
34.     std::cout << "Files created successfully." << std::endl;
35.    
36.     return 0;
37. }

复制代码

写入二进制数据

使用二进制模式可以高效地写入原始数据：

2. #include <iostream>
3. #include <fstream>
5. struct Person {
6.     char name[50];
7.     int age;
8.     double salary;
9. };
11. int main() {
12.     Person person = {"John Doe", 30, 50000.50};
13.    
14.     // 以二进制模式打开文件
15.     std::ofstream outFile("person.dat", std::ios::binary);
16.    
17.     if (!outFile) {
18.         std::cerr << "Error: Could not open file for writing." << std::endl;
19.         return 1;
20.     }
21.    
22.     // 写入二进制数据
23.     outFile.write(reinterpret_cast<const char*>(&person), sizeof(Person));
24.    
25.     outFile.close();
26.    
27.     std::cout << "Binary data written to file successfully." << std::endl;
28.    
29.     return 0;
30. }

复制代码

文件位置指针

文件流维护一个位置指针，指示下一个读/写操作的位置。对于输出流，可以使用seekp()方法设置位置指针：

2. #include <iostream>
3. #include <fstream>
4. #include <string>
6. int main() {
7.     std::ofstream outFile("data.txt");
8.    
9.     if (!outFile) {
10.         std::cerr << "Error: Could not open file for writing." << std::endl;
11.         return 1;
12.     }
13.    
14.     // 写入一些数据
15.     outFile << "1234567890" << std::endl;
16.    
17.     // 获取当前位置
18.     std::streampos pos = outFile.tellp();
19.     std::cout << "Current position: " << pos << std::endl;
20.    
21.     // 移动到文件开头
22.     outFile.seekp(0, std::ios::beg);
23.    
24.     // 在开头写入新数据
25.     outFile << "ABCDE";
26.    
27.     // 移动到文件末尾
28.     outFile.seekp(0, std::ios::end);
29.    
30.     // 在末尾追加数据
31.     outFile << "FGHIJ" << std::endl;
32.    
33.     outFile.close();
34.    
35.     std::cout << "Data written with positioning successfully." << std::endl;
36.    
37.     return 0;
38. }

复制代码

刷新输出缓冲区

输出流通常使用缓冲区来提高性能。有时需要强制刷新缓冲区，确保数据立即写入：

2. #include <iostream>
3. #include <fstream>
5. int main() {
6.     std::ofstream outFile("buffered.txt");
7.    
8.     if (!outFile) {
9.         std::cerr << "Error: Could not open file for writing." << std::endl;
10.         return 1;
11.     }
12.    
13.     // 写入数据(可能还在缓冲区中)
14.     outFile << "This data might be buffered." << std::endl;
15.    
16.     // 手动刷新缓冲区
17.     outFile.flush();
18.    
19.     // 写入更多数据
20.     outFile << "This data will also be buffered." << std::endl;
21.    
22.     // 关闭文件时会自动刷新缓冲区
23.     outFile.close();
24.    
25.     std::cout << "Buffered output completed successfully." << std::endl;
26.    
27.     return 0;
28. }

复制代码

错误处理

检查流状态

C++的流对象维护一个状态标志，可以用来检查操作是否成功：

2. #include <iostream>
3. #include <fstream>
5. int main() {
6.     std::ifstream inFile("nonexistent.txt");
7.    
8.     // 检查文件是否成功打开
9.     if (!inFile) {
10.         std::cerr << "Error: Could not open file." << std::endl;
11.         
12.         // 检查具体错误状态
13.         if (inFile.fail()) {
14.             std::cerr << "Fail bit is set." << std::endl;
15.         }
16.         
17.         return 1;
18.     }
19.    
20.     // 读取文件内容
21.     char ch;
22.     while (inFile.get(ch)) {
23.         std::cout << ch;
24.     }
25.    
26.     // 检查是否到达文件末尾
27.     if (inFile.eof()) {
28.         std::cout << "\nReached end of file." << std::endl;
29.     }
30.    
31.     inFile.close();
32.    
33.     return 0;
34. }

复制代码

异常处理

可以配置流对象在遇到错误时抛出异常：

2. #include <iostream>
3. #include <fstream>
4. #include <stdexcept>
6. int main() {
7.     // 设置在失败时抛出异常
8.     std::ifstream inFile;
9.     inFile.exceptions(std::ifstream::failbit | std::ifstream::badbit);
10.    
11.     try {
12.         inFile.open("nonexistent.txt");
13.         
14.         // 读取文件内容
15.         char ch;
16.         while (inFile.get(ch)) {
17.             std::cout << ch;
18.         }
19.         
20.         inFile.close();
21.     }
22.     catch (const std::ifstream::failure& e) {
23.         std::cerr << "Exception opening/reading file: " << e.what() << std::endl;
24.         return 1;
25.     }
26.    
27.     return 0;
28. }

复制代码

处理输出错误

输出操作也可能失败，例如磁盘空间不足或文件权限问题：

2. #include <iostream>
3. #include <fstream>
4. #include <string>
6. int main() {
7.     std::ofstream outFile("/root/protected.txt");  // 假设我们没有权限写入此目录
8.    
9.     if (!outFile) {
10.         std::cerr << "Error: Could not open file for writing." << std::endl;
11.         
12.         // 检查具体错误
13.         if (outFile.fail()) {
14.             std::cerr << "Fail bit is set. Possible reasons:" << std::endl;
15.             std::cerr << "- File does not exist" << std::endl;
16.             std::cerr << "- No permission to write" << std::endl;
17.             std::cerr << "- Disk full" << std::endl;
18.         }
19.         
20.         return 1;
21.     }
22.    
23.     try {
24.         // 尝试写入大量数据(可能导致磁盘空间不足)
25.         for (int i = 0; i < 1000000; ++i) {
26.             outFile << "This is line " << i << " with some sample text." << std::endl;
27.             
28.             // 定期检查错误状态
29.             if (outFile.fail()) {
30.                 throw std::runtime_error("Failed to write to file.");
31.             }
32.         }
33.     }
34.     catch (const std::exception& e) {
35.         std::cerr << "Exception: " << e.what() << std::endl;
36.         outFile.close();
37.         return 1;
38.     }
39.    
40.     outFile.close();
41.     std::cout << "Data written successfully." << std::endl;
42.    
43.     return 0;
44. }

复制代码

自定义错误处理

可以创建自定义的错误处理函数，并将其与流对象关联：

2. #include <iostream>
3. #include <fstream>
5. void customErrorHandler(std::ios_base::failure& e, const std::string& filename) {
6.     std::cerr << "Custom error handler for file: " << filename << std::endl;
7.     std::cerr << "Error: " << e.what() << std::endl;
8.    
9.     // 可以在这里添加恢复逻辑，如尝试创建备份文件等
10. }
12. int main() {
13.     std::ofstream outFile;
14.    
15.     // 设置在失败时抛出异常
16.     outFile.exceptions(std::ofstream::failbit | std::ofstream::badbit);
17.    
18.     try {
19.         outFile.open("readonly.txt");  // 假设这是一个只读文件
20.         
21.         // 尝试写入
22.         outFile << "This should fail." << std::endl;
23.         
24.         outFile.close();
25.     }
26.     catch (std::ios_base::failure& e) {
27.         customErrorHandler(e, "readonly.txt");
28.         return 1;
29.     }
30.    
31.     return 0;
32. }

复制代码

高级应用

重定向标准输出

有时需要将标准输出重定向到文件或其他设备：

2. #include <iostream>
3. #include <fstream>
4. #include <string>
6. void printToConsole() {
7.     std::cout << "This message goes to the console." << std::endl;
8. }
10. void printToFile(const std::string& filename) {
11.     // 保存原始的cout缓冲区
12.     std::streambuf* originalCoutBuffer = std::cout.rdbuf();
13.    
14.     // 打开文件
15.     std::ofstream outFile(filename);
16.    
17.     if (!outFile) {
18.         std::cerr << "Error: Could not open file for writing." << std::endl;
19.         return;
20.     }
21.    
22.     // 重定向cout到文件
23.     std::cout.rdbuf(outFile.rdbuf());
24.    
25.     // 现在cout输出将写入文件
26.     std::cout << "This message goes to the file." << std::endl;
27.    
28.     // 恢复原始的cout缓冲区
29.     std::cout.rdbuf(originalCoutBuffer);
30.    
31.     // 关闭文件
32.     outFile.close();
33.    
34.     std::cout << "Message redirected to file successfully." << std::endl;
35. }
37. int main() {
38.     printToConsole();
39.     printToFile("redirected.txt");
40.    
41.     return 0;
42. }

复制代码

使用字符串流进行格式化

C++的stringstream类允许将输出格式化到字符串中，然后再输出：

2. #include <iostream>
3. #include <sstream>
4. #include <iomanip>
5. #include <string>
7. std::string formatPerson(const std::string& name, int age, double height) {
8.     std::ostringstream oss;
9.    
10.     oss << "Name: " << std::left << std::setw(20) << name
11.         << "Age: " << std::setw(3) << age
12.         << "Height: " << std::fixed << std::setprecision(2) << height << "m";
13.    
14.     return oss.str();
15. }
17. int main() {
18.     std::string formatted = formatPerson("John Smith", 30, 1.75);
19.     std::cout << formatted << std::endl;
20.    
21.     // 也可以直接使用stringstream进行复杂的格式化
22.     std::ostringstream report;
23.     report << "Sales Report\n"
24.            << "------------\n"
25.            << "Item: " << std::setw(15) << std::left << "Laptop"
26.            << "Price: $" << std::setw(10) << std::right << std::fixed << std::setprecision(2) << 999.99 << "\n"
27.            << "Item: " << std::setw(15) << std::left << "Mouse"
28.            << "Price: $" << std::setw(10) << std::right << std::fixed << std::setprecision(2) << 19.99 << "\n"
29.            << "Item: " << std::setw(15) << std::left << "Keyboard"
30.            << "Price: $" << std::setw(10) << std::right << std::fixed << std::setprecision(2) << 49.99 << "\n";
31.    
32.     std::cout << report.str();
33.    
34.     return 0;
35. }

复制代码

多线程输出

在多线程环境中，输出操作需要同步以避免数据竞争：

2. #include <iostream>
3. #include <thread>
4. #include <mutex>
5. #include <chrono>
7. std::mutex coutMutex;  // 用于同步cout的互斥锁
9. void threadFunction(int id) {
10.     for (int i = 0; i < 5; ++i) {
11.         // 使用lock_guard自动管理锁的生命周期
12.         std::lock_guard<std::mutex> lock(coutMutex);
13.         
14.         std::cout << "Thread " << id << ": Message " << i << std::endl;
15.         
16.         // 锁在lock_guard析构时自动释放
17.     }
18. }
20. int main() {
21.     std::thread t1(threadFunction, 1);
22.     std::thread t2(threadFunction, 2);
23.    
24.     t1.join();
25.     t2.join();
26.    
27.     std::cout << "All threads completed." << std::endl;
28.    
29.     return 0;
30. }

复制代码

输出到多个目标

有时需要将相同的输出同时发送到多个目标，例如控制台和文件：

2. #include <iostream>
3. #include <fstream>
4. #include <string>
6. class MultiOutputStream {
7. private:
8.     std::ostream& stream1;
9.     std::ostream& stream2;
10.    
11. public:
12.     MultiOutputStream(std::ostream& s1, std::ostream& s2) : stream1(s1), stream2(s2) {}
13.    
14.     template<typename T>
15.     MultiOutputStream& operator<<(const T& value) {
16.         stream1 << value;
17.         stream2 << value;
18.         return *this;
19.     }
20.    
21.     // 处理操纵符(如std::endl)
22.     MultiOutputStream& operator<<(std::ostream& (*manip)(std::ostream&)) {
23.         stream1 << manip;
24.         stream2 << manip;
25.         return *this;
26.     }
27. };
29. int main() {
30.     std::ofstream logFile("log.txt");
31.    
32.     if (!logFile) {
33.         std::cerr << "Error: Could not open log file." << std::endl;
34.         return 1;
35.     }
36.    
37.     MultiOutputStream multiOut(std::cout, logFile);
38.    
39.     multiOut << "This message goes to both console and file." << std::endl;
40.     multiOut << "Error: Something went wrong!" << std::endl;
41.     multiOut << "Warning: Low disk space." << std::endl;
42.    
43.     logFile.close();
44.    
45.     std::cout << "Multi-output completed successfully." << std::endl;
46.    
47.     return 0;
48. }

复制代码

国际化输出

处理不同语言和地区的输出：

2. #include <iostream>
3. #include <locale>
4. #include <iomanip>
6. int main() {
7.     // 设置本地化环境
8.     std::locale::global(std::locale(""));
9.     std::cout.imbue(std::locale());
10.    
11.     // 输出数字(使用本地化的数字格式)
12.     double number = 1234567.89;
13.     std::cout << "Localized number: " << number << std::endl;
14.    
15.     // 输出货币(使用本地化的货币格式)
16.     std::cout << "Localized currency: " << std::put_money(123456) << std::endl;
17.    
18.     // 输出时间(使用本地化的时间格式)
19.     time_t now = time(nullptr);
20.     std::tm tm = *std::localtime(&now);
21.     std::cout << "Localized time: " << std::put_time(&tm, "%c") << std::endl;
22.    
23.     return 0;
24. }

复制代码

常见错误及避免方法

1. 未检查文件是否成功打开

错误示例：

2. #include <iostream>
3. #include <fstream>
5. int main() {
6.     std::ofstream outFile("readonly.txt");  // 假设这是一个只读文件
7.    
8.     // 未检查文件是否成功打开
9.     outFile << "This will fail silently." << std::endl;
10.     outFile.close();
11.    
12.     return 0;
13. }

复制代码

正确方法：

2. #include <iostream>
3. #include <fstream>
5. int main() {
6.     std::ofstream outFile("readonly.txt");
7.    
8.     // 检查文件是否成功打开
9.     if (!outFile) {
10.         std::cerr << "Error: Could not open file for writing." << std::endl;
11.         return 1;
12.     }
13.    
14.     outFile << "This will work if the file is writable." << std::endl;
15.     outFile.close();
16.    
17.     return 0;
18. }

复制代码

2. 忘记关闭文件

错误示例：

2. #include <iostream>
3. #include <fstream>
5. int main() {
6.     std::ofstream outFile("data.txt");
7.    
8.     if (!outFile) {
9.         std::cerr << "Error: Could not open file for writing." << std::endl;
10.         return 1;
11.     }
12.    
13.     outFile << "Some data" << std::endl;
14.    
15.     // 忘记关闭文件
16.    
17.     return 0;
18. }

复制代码

正确方法：

2. #include <iostream>
3. #include <fstream>
5. int main() {
6.     std::ofstream outFile("data.txt");
7.    
8.     if (!outFile) {
9.         std::cerr << "Error: Could not open file for writing." << std::endl;
10.         return 1;
11.     }
12.    
13.     outFile << "Some data" << std::endl;
14.    
15.     // 显式关闭文件
16.     outFile.close();
17.    
18.     return 0;
19. }

复制代码

更好的方法(使用RAII)：

2. #include <iostream>
3. #include <fstream>
5. void writeData() {
6.     // 文件将在函数结束时自动关闭
7.     std::ofstream outFile("data.txt");
8.    
9.     if (!outFile) {
10.         std::cerr << "Error: Could not open file for writing." << std::endl;
11.         return;
12.     }
13.    
14.     outFile << "Some data" << std::endl;
15.     // 不需要显式关闭文件，它会在outFile析构时自动关闭
16. }
18. int main() {
19.     writeData();
20.     return 0;
21. }

复制代码

3. 错误使用格式化操纵符

错误示例：

2. #include <iostream>
3. #include <iomanip>
5. int main() {
6.     double number = 123.456789;
7.    
8.     // 错误：std::fixed和std::scientific同时使用
9.     std::cout << std::fixed << std::scientific << number << std::endl;
10.    
11.     return 0;
12. }

复制代码

正确方法：

2. #include <iostream>
3. #include <iomanip>
5. int main() {
6.     double number = 123.456789;
7.    
8.     // 正确：使用一种格式
9.     std::cout << "Fixed: " << std::fixed << number << std::endl;
10.    
11.     // 重置格式
12.     std::cout.unsetf(std::ios_base::floatfield);
13.    
14.     // 使用另一种格式
15.     std::cout << "Scientific: " << std::scientific << number << std::endl;
16.    
17.     return 0;
18. }

复制代码

4. 缓冲区刷新问题

错误示例：

2. #include <iostream>
3. #include <fstream>
5. int main() {
6.     std::ofstream outFile("buffered.txt");
7.    
8.     if (!outFile) {
9.         std::cerr << "Error: Could not open file for writing." << std::endl;
10.         return 1;
11.     }
12.    
13.     // 写入重要数据，但不刷新缓冲区
14.     outFile << "Critical data that must be written immediately";
15.    
16.     // 程序可能在这里崩溃，导致数据丢失
17.    
18.     outFile.close();
19.    
20.     return 0;
21. }

复制代码

正确方法：

2. #include <iostream>
3. #include <fstream>
5. int main() {
6.     std::ofstream outFile("buffered.txt");
7.    
8.     if (!outFile) {
9.         std::cerr << "Error: Could not open file for writing." << std::endl;
10.         return 1;
11.     }
12.    
13.     // 写入重要数据
14.     outFile << "Critical data that must be written immediately";
15.    
16.     // 立即刷新缓冲区
17.     outFile.flush();
18.    
19.     // 现在即使程序崩溃，数据也已经写入文件
20.    
21.     outFile.close();
22.    
23.     return 0;
24. }

复制代码

5. 二进制模式下的文本输出

错误示例：

2. #include <iostream>
3. #include <fstream>
5. int main() {
6.     // 以二进制模式打开文件
7.     std::ofstream outFile("binary.dat", std::ios::binary);
8.    
9.     if (!outFile) {
10.         std::cerr << "Error: Could not open file for writing." << std::endl;
11.         return 1;
12.     }
13.    
14.     // 错误：在二进制模式下使用文本输出
15.     outFile << "Hello, World!" << std::endl;
16.    
17.     outFile.close();
18.    
19.     return 0;
20. }

复制代码

正确方法：

2. #include <iostream>
3. #include <fstream>
4. #include <string>
6. int main() {
7.     // 对于文本数据，使用文本模式
8.     std::ofstream textFile("text.txt");
9.     if (textFile) {
10.         textFile << "Hello, World!" << std::endl;
11.         textFile.close();
12.     }
13.    
14.     // 对于二进制数据，使用二进制模式
15.     std::ofstream binaryFile("binary.dat", std::ios::binary);
16.     if (binaryFile) {
17.         int numbers[] = {1, 2, 3, 4, 5};
18.         binaryFile.write(reinterpret_cast<const char*>(numbers), sizeof(numbers));
19.         binaryFile.close();
20.     }
21.    
22.     return 0;
23. }

复制代码

6. 忽略错误状态

错误示例：

2. #include <iostream>
3. #include <fstream>
5. int main() {
6.     std::ofstream outFile("disk_full.txt");
7.    
8.     if (!outFile) {
9.         std::cerr << "Error: Could not open file for writing." << std::endl;
10.         return 1;
11.     }
12.    
13.     // 尝试写入大量数据(可能导致磁盘空间不足)
14.     for (int i = 0; i < 1000000; ++i) {
15.         outFile << "This is line " << i << " with some sample text." << std::endl;
16.         // 不检查错误状态
17.     }
18.    
19.     outFile.close();
20.    
21.     return 0;
22. }

复制代码

正确方法：

2. #include <iostream>
3. #include <fstream>
5. int main() {
6.     std::ofstream outFile("disk_full.txt");
7.    
8.     if (!outFile) {
9.         std::cerr << "Error: Could not open file for writing." << std::endl;
10.         return 1;
11.     }
12.    
13.     // 尝试写入大量数据
14.     for (int i = 0; i < 1000000; ++i) {
15.         outFile << "This is line " << i << " with some sample text." << std::endl;
16.         
17.         // 定期检查错误状态
18.         if (outFile.fail()) {
19.             std::cerr << "Error: Failed to write to file. Disk may be full." << std::endl;
20.             outFile.close();
21.             return 1;
22.         }
23.     }
24.    
25.     outFile.close();
26.    
27.     return 0;
28. }

复制代码

实战案例

案例1：生成格式化报告

假设我们需要生成一个销售报告，包含产品信息、销售额和统计信息，并输出到控制台和文件。

2. #include <iostream>
3. #include <fstream>
4. #include <iomanip>
5. #include <vector>
6. #include <string>
7. #include <algorithm>
9. struct Product {
10.     std::string name;
11.     int quantity;
12.     double price;
13. };
15. class ReportGenerator {
16. private:
17.     std::vector<Product> products;
18.    
19. public:
20.     void addProduct(const std::string& name, int quantity, double price) {
21.         products.push_back({name, quantity, price});
22.     }
23.    
24.     double calculateTotalSales() const {
25.         double total = 0.0;
26.         for (const auto& product : products) {
27.             total += product.quantity * product.price;
28.         }
29.         return total;
30.     }
31.    
32.     std::string getBestSellingProduct() const {
33.         if (products.empty()) return "None";
34.         
35.         auto it = std::max_element(products.begin(), products.end(),
36.             [](const Product& a, const Product& b) {
37.                 return a.quantity < b.quantity;
38.             });
39.         
40.         return it->name;
41.     }
42.    
43.     void generateReport(std::ostream& out) const {
44.         // 设置格式
45.         out << std::fixed << std::setprecision(2);
46.         
47.         // 报告标题
48.         out << "SALES REPORT" << std::endl;
49.         out << "============" << std::endl << std::endl;
50.         
51.         // 表头
52.         out << std::left << std::setw(20) << "Product"
53.             << std::right << std::setw(10) << "Quantity"
54.             << std::setw(15) << "Unit Price"
55.             << std::setw(15) << "Total" << std::endl;
56.         
57.         out << std::string(60, '-') << std::endl;
58.         
59.         // 产品数据
60.         for (const auto& product : products) {
61.             double total = product.quantity * product.price;
62.             out << std::left << std::setw(20) << product.name
63.                 << std::right << std::setw(10) << product.quantity
64.                 << std::setw(15) << product.price
65.                 << std::setw(15) << total << std::endl;
66.         }
67.         
68.         out << std::string(60, '-') << std::endl;
69.         
70.         // 统计信息
71.         out << std::left << std::setw(20) << "Total Sales:"
72.             << std::right << std::setw(40) << calculateTotalSales() << std::endl;
73.         
74.         out << std::left << std::setw(20) << "Best Selling Product:"
75.             << std::right << std::setw(40) << getBestSellingProduct() << std::endl;
76.         
77.         out << std::endl << "Report generated on: ";
78.         
79.         // 输出当前日期和时间
80.         time_t now = time(nullptr);
81.         tm tm = *localtime(&now);
82.         out << std::put_time(&tm, "%Y-%m-%d %H:%M:%S") << std::endl;
83.     }
84. };
86. int main() {
87.     ReportGenerator generator;
88.    
89.     // 添加产品数据
90.     generator.addProduct("Laptop", 15, 999.99);
91.     generator.addProduct("Smartphone", 30, 699.99);
92.     generator.addProduct("Tablet", 20, 399.99);
93.     generator.addProduct("Headphones", 50, 99.99);
94.     generator.addProduct("Smartwatch", 25, 249.99);
95.    
96.     // 输出到控制台
97.     generator.generateReport(std::cout);
98.    
99.     // 输出到文件
100.     std::ofstream reportFile("sales_report.txt");
101.     if (reportFile) {
102.         generator.generateReport(reportFile);
103.         reportFile.close();
104.         std::cout << "\nReport also saved to 'sales_report.txt'." << std::endl;
105.     } else {
106.         std::cerr << "Error: Could not save report to file." << std::endl;
107.     }
108.    
109.     return 0;
110. }

复制代码

案例2：日志系统

创建一个多功能的日志系统，支持不同级别的日志输出，并能同时输出到控制台和文件。

2. #include <iostream>
3. #include <fstream>
4. #include <string>
5. #include <ctime>
6. #include <iomanip>
7. #include <mutex>
8. #include <sstream>
10. enum class LogLevel {
11.     DEBUG,
12.     INFO,
13.     WARNING,
14.     ERROR,
15.     CRITICAL
16. };
18. class Logger {
19. private:
20.     std::ofstream logFile;
21.     std::mutex logMutex;
22.     LogLevel currentLevel = LogLevel::INFO;
23.     bool consoleOutput = true;
24.     bool fileOutput = false;
25.    
26.     std::string levelToString(LogLevel level) {
27.         switch (level) {
28.             case LogLevel::DEBUG:    return "DEBUG";
29.             case LogLevel::INFO:     return "INFO";
30.             case LogLevel::WARNING:  return "WARNING";
31.             case LogLevel::ERROR:    return "ERROR";
32.             case LogLevel::CRITICAL: return "CRITICAL";
33.             default:                 return "UNKNOWN";
34.         }
35.     }
36.    
37.     std::string getCurrentTime() {
38.         time_t now = time(nullptr);
39.         tm tm = *localtime(&now);
40.         
41.         std::ostringstream oss;
42.         oss << std::put_time(&tm, "%Y-%m-%d %H:%M:%S");
43.         return oss.str();
44.     }
45.    
46. public:
47.     Logger() = default;
48.    
49.     ~Logger() {
50.         if (logFile.is_open()) {
51.             logFile.close();
52.         }
53.     }
54.    
55.     bool setLogFile(const std::string& filename) {
56.         std::lock_guard<std::mutex> lock(logMutex);
57.         
58.         if (logFile.is_open()) {
59.             logFile.close();
60.         }
61.         
62.         logFile.open(filename, std::ios::app);
63.         if (!logFile) {
64.             std::cerr << "Error: Could not open log file: " << filename << std::endl;
65.             return false;
66.         }
67.         
68.         fileOutput = true;
69.         return true;
70.     }
71.    
72.     void setLogLevel(LogLevel level) {
73.         currentLevel = level;
74.     }
75.    
76.     void enableConsoleOutput(bool enable) {
77.         consoleOutput = enable;
78.     }
79.    
80.     void enableFileOutput(bool enable) {
81.         fileOutput = enable;
82.     }
83.    
84.     void log(LogLevel level, const std::string& message) {
85.         if (level < currentLevel) {
86.             return;
87.         }
88.         
89.         std::lock_guard<std::mutex> lock(logMutex);
90.         
91.         std::string logEntry = "[" + getCurrentTime() + "] [" +
92.                               levelToString(level) + "] " + message;
93.         
94.         if (consoleOutput) {
95.             // 根据日志级别设置不同的颜色
96.             switch (level) {
97.                 case LogLevel::DEBUG:
98.                     std::cout << "\033[36m";  // 青色
99.                     break;
100.                 case LogLevel::INFO:
101.                     std::cout << "\033[32m";  // 绿色
102.                     break;
103.                 case LogLevel::WARNING:
104.                     std::cout << "\033[33m";  // 黄色
105.                     break;
106.                 case LogLevel::ERROR:
107.                     std::cout << "\033[31m";  // 红色
108.                     break;
109.                 case LogLevel::CRITICAL:
110.                     std::cout << "\033[1;31m";  // 亮红色
111.                     break;
112.             }
113.             
114.             std::cout << logEntry << "\033[0m" << std::endl;
115.         }
116.         
117.         if (fileOutput && logFile.is_open()) {
118.             logFile << logEntry << std::endl;
119.             logFile.flush();  // 确保日志立即写入文件
120.         }
121.     }
122.    
123.     // 便捷方法
124.     void debug(const std::string& message) { log(LogLevel::DEBUG, message); }
125.     void info(const std::string& message) { log(LogLevel::INFO, message); }
126.     void warning(const std::string& message) { log(LogLevel::WARNING, message); }
127.     void error(const std::string& message) { log(LogLevel::ERROR, message); }
128.     void critical(const std::string& message) { log(LogLevel::CRITICAL, message); }
129. };
131. // 全局日志对象
132. Logger logger;
134. int main() {
135.     // 配置日志系统
136.     logger.setLogFile("application.log");
137.     logger.setLogLevel(LogLevel::DEBUG);
138.    
139.     // 记录一些日志消息
140.     logger.debug("Application starting up...");
141.     logger.info("Initializing components...");
142.    
143.     // 模拟一些操作
144.     try {
145.         logger.info("Performing operation A...");
146.         // 模拟成功
147.         logger.info("Operation A completed successfully.");
148.         
149.         logger.warning("This is a warning message.");
150.         
151.         logger.info("Performing operation B...");
152.         // 模拟错误
153.         throw std::runtime_error("Simulated error in operation B");
154.     }
155.     catch (const std::exception& e) {
156.         logger.error(std::string("Operation failed: ") + e.what());
157.     }
158.    
159.     logger.critical("This is a critical message.");
160.     logger.info("Application shutting down.");
161.    
162.     std::cout << "Log messages have been written to console and 'application.log'." << std::endl;
163.    
164.     return 0;
165. }

复制代码

案例3：数据导出工具

创建一个将数据库查询结果导出为CSV文件的工具。

2. #include <iostream>
3. #include <fstream>
4. #include <vector>
5. #include <string>
6. #include <iomanip>
7. #include <sstream>
9. // 模拟数据库记录
10. struct Record {
11.     int id;
12.     std::string name;
13.     double value;
14.     std::string category;
15.     std::string date;
16. };
18. class DataExporter {
19. private:
20.     std::vector<Record> records;
21.    
22.     // 转义CSV字段中的特殊字符
23.     std::string escapeCsvField(const std::string& field) {
24.         // 如果字段包含逗号、双引号或换行符，需要用双引号包围
25.         // 并且字段中的双引号需要转义为两个双引号
26.         if (field.find(',') != std::string::npos ||
27.             field.find('"') != std::string::npos ||
28.             field.find('\n') != std::string::npos) {
29.             
30.             std::string escaped = """;
31.             for (char c : field) {
32.                 if (c == '"') {
33.                     escaped += """";
34.                 } else {
35.                     escaped += c;
36.                 }
37.             }
38.             escaped += """;
39.             return escaped;
40.         }
41.         return field;
42.     }
43.    
44. public:
45.     void addRecord(const Record& record) {
46.         records.push_back(record);
47.     }
48.    
49.     bool exportToCsv(const std::string& filename) {
50.         std::ofstream outFile(filename);
51.         
52.         if (!outFile) {
53.             std::cerr << "Error: Could not open file " << filename << " for writing." << std::endl;
54.             return false;
55.         }
56.         
57.         // 写入CSV头部
58.         outFile << "ID,Name,Value,Category,Date" << std::endl;
59.         
60.         // 写入数据
61.         for (const auto& record : records) {
62.             outFile << record.id << ","
63.                     << escapeCsvField(record.name) << ","
64.                     << std::fixed << std::setprecision(2) << record.value << ","
65.                     << escapeCsvField(record.category) << ","
66.                     << escapeCsvField(record.date) << std::endl;
67.         }
68.         
69.         outFile.close();
70.         
71.         std::cout << "Successfully exported " << records.size() << " records to " << filename << std::endl;
72.         return true;
73.     }
74.    
75.     bool exportToHtml(const std::string& filename) {
76.         std::ofstream outFile(filename);
77.         
78.         if (!outFile) {
79.             std::cerr << "Error: Could not open file " << filename << " for writing." << std::endl;
80.             return false;
81.         }
82.         
83.         // 写入HTML头部
84.         outFile << "<!DOCTYPE html>" << std::endl;
85.         outFile << "<html>" << std::endl;
86.         outFile << "<head>" << std::endl;
87.         outFile << "<title>Data Export</title>" << std::endl;
88.         outFile << "<style>" << std::endl;
89.         outFile << "table { border-collapse: collapse; width: 100%; }" << std::endl;
90.         outFile << "th, td { border: 1px solid #ddd; padding: 8px; text-align: left; }" << std::endl;
91.         outFile << "th { background-color: #f2f2f2; }" << std::endl;
92.         outFile << "tr:nth-child(even) { background-color: #f9f9f9; }" << std::endl;
93.         outFile << "</style>" << std::endl;
94.         outFile << "</head>" << std::endl;
95.         outFile << "<body>" << std::endl;
96.         outFile << "<h1>Data Export</h1>" << std::endl;
97.         outFile << "<table>" << std::endl;
98.         
99.         // 写入表头
100.         outFile << "<tr><th>ID</th><th>Name</th><th>Value</th><th>Category</th><th>Date</th></tr>" << std::endl;
101.         
102.         // 写入数据
103.         for (const auto& record : records) {
104.             outFile << "<tr>"
105.                     << "<td>" << record.id << "</td>"
106.                     << "<td>" << record.name << "</td>"
107.                     << "<td>" << std::fixed << std::setprecision(2) << record.value << "</td>"
108.                     << "<td>" << record.category << "</td>"
109.                     << "<td>" << record.date << "</td>"
110.                     << "</tr>" << std::endl;
111.         }
112.         
113.         // 写入HTML尾部
114.         outFile << "</table>" << std::endl;
115.         outFile << "</body>" << std::endl;
116.         outFile << "</html>" << std::endl;
117.         
118.         outFile.close();
119.         
120.         std::cout << "Successfully exported " << records.size() << " records to " << filename << std::endl;
121.         return true;
122.     }
123.    
124.     void printSummary() {
125.         if (records.empty()) {
126.             std::cout << "No records to summarize." << std::endl;
127.             return;
128.         }
129.         
130.         // 计算统计信息
131.         double totalValue = 0.0;
132.         double minValue = records[0].value;
133.         double maxValue = records[0].value;
134.         
135.         for (const auto& record : records) {
136.             totalValue += record.value;
137.             if (record.value < minValue) minValue = record.value;
138.             if (record.value > maxValue) maxValue = record.value;
139.         }
140.         
141.         // 输出摘要
142.         std::cout << std::fixed << std::setprecision(2);
143.         std::cout << "Data Summary:" << std::endl;
144.         std::cout << "=============" << std::endl;
145.         std::cout << "Total Records: " << records.size() << std::endl;
146.         std::cout << "Total Value: " << totalValue << std::endl;
147.         std::cout << "Average Value: " << (totalValue / records.size()) << std::endl;
148.         std::cout << "Minimum Value: " << minValue << std::endl;
149.         std::cout << "Maximum Value: " << maxValue << std::endl;
150.     }
151. };
153. int main() {
154.     DataExporter exporter;
155.    
156.     // 添加一些示例数据
157.     exporter.addRecord({1, "Product A", 125.50, "Electronics", "2023-01-15"});
158.     exporter.addRecord({2, "Product B", 89.99, "Clothing", "2023-01-16"});
159.     exporter.addRecord({3, "Product C", 45.00, "Home & Garden", "2023-01-17"});
160.     exporter.addRecord({4, "Product D", "Special, "Limited" Edition", 199.99, "Collectibles", "2023-01-18"});
161.     exporter.addRecord({5, "Product E", 75.25, "Electronics", "2023-01-19"});
162.    
163.     // 打印摘要
164.     exporter.printSummary();
165.     std::cout << std::endl;
166.    
167.     // 导出为CSV
168.     if (!exporter.exportToCsv("data_export.csv")) {
169.         return 1;
170.     }
171.    
172.     // 导出为HTML
173.     if (!exporter.exportToHtml("data_export.html")) {
174.         return 1;
175.     }
176.    
177.     std::cout << "Data export completed successfully." << std::endl;
178.    
179.     return 0;
180. }

复制代码

总结

本教程全面介绍了C++输出编程的各个方面，从基础语法到高级应用。我们学习了：

1. 基础输出：使用cout进行基本输出操作，处理不同数据类型，以及链式输出的技巧。
2. 格式化输出：控制输出宽度、填充字符、对齐方式，以及数值格式、布尔值和整数的进制表示。
3. 文件输出：使用ofstream进行文件操作，包括不同的文件打开模式、二进制数据写入、文件位置指针操作和缓冲区管理。
4. 错误处理：检查流状态、使用异常处理、处理输出错误，以及实现自定义错误处理。
5. 高级应用：重定向标准输出、使用字符串流进行格式化、多线程输出、输出到多个目标，以及国际化输出。
6. 常见错误及避免方法：识别并避免C++输出编程中的常见错误，如未检查文件是否成功打开、忘记关闭文件、错误使用格式化操纵符等。
7. 实战案例：通过生成格式化报告、创建日志系统和数据导出工具等实际案例，展示了如何将所学知识应用到实际问题中。

基础输出：使用cout进行基本输出操作，处理不同数据类型，以及链式输出的技巧。

格式化输出：控制输出宽度、填充字符、对齐方式，以及数值格式、布尔值和整数的进制表示。

文件输出：使用ofstream进行文件操作，包括不同的文件打开模式、二进制数据写入、文件位置指针操作和缓冲区管理。

错误处理：检查流状态、使用异常处理、处理输出错误，以及实现自定义错误处理。

高级应用：重定向标准输出、使用字符串流进行格式化、多线程输出、输出到多个目标，以及国际化输出。

常见错误及避免方法：识别并避免C++输出编程中的常见错误，如未检查文件是否成功打开、忘记关闭文件、错误使用格式化操纵符等。

实战案例：通过生成格式化报告、创建日志系统和数据导出工具等实际案例，展示了如何将所学知识应用到实际问题中。

通过本教程的学习，您应该已经掌握了C++输出编程的核心技能，能够解决现实编程中的输出难题，提升开发技能，并避免常见的输出编程错误。继续实践和探索，您将能够更加熟练地运用这些技术，开发出更加健壮和高效的C++应用程序。