C++编程中的输出操作符<<详细教程从零开始学习cout和<<的使用方法解决实际编程中的输出挑战和优化代码

威震华夏关云长 · 发表于 2025-9-11 16:00:00

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

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

x

引言

C++作为一种强大而灵活的编程语言，提供了多种输入输出机制。其中，使用输出操作符<<和cout对象进行输出是最基础也是最常用的方法之一。无论是初学者还是有经验的程序员，掌握输出操作都是编写有效程序的关键步骤。本教程将从零开始，详细介绍C++中的输出操作符<<和cout的使用方法，帮助读者解决实际编程中的输出挑战，并优化代码。

基础知识：理解cout和<<操作符

在C++中，cout是标准输出流（standard output stream）的对象，它属于C++标准库中的iostream类。cout通常与显示器（控制台）相关联，用于将数据输出到屏幕上。

而<<操作符，在C++中被称为”插入操作符”（insertion operator）或”输出操作符”。当用于输出时，它将右侧的数据”插入”到左侧的流中。例如，cout << "Hello"表示将字符串”Hello”插入到标准输出流中，最终显示在屏幕上。

要使用cout和<<，首先需要包含头文件<iostream>：

#include <iostream>

复制代码

基本用法：简单的输出操作

输出字符串

最基本的输出操作是输出字符串：

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

复制代码

这个程序会在屏幕上显示”Hello, World!“。

输出换行

要在输出后换行，可以使用std::endl或转义字符\n：

#include <iostream>
int main() {
std::cout << "Hello, World!" << std::endl; // 使用std::endl换行
std::cout << "Welcome to C++ programming.\n"; // 使用\n换行
return 0;
}

复制代码

std::endl和\n的区别在于：

• std::endl会插入一个换行符，并刷新输出缓冲区。
• \n只插入一个换行符，不刷新缓冲区。

刷新缓冲区意味着立即将缓冲区中的内容输出到目标设备（如屏幕）。频繁刷新缓冲区可能会影响性能，因此在性能敏感的场景下，使用\n可能更合适。

链式输出

<<操作符可以链式使用，一次输出多个项目：

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

复制代码

格式化输出：控制输出格式

C++提供了多种方式来控制输出的格式，包括设置宽度、精度、填充字符等。

设置输出宽度

使用std::setw（来自<iomanip>头文件）可以设置输出的最小宽度：

#include <iostream>
#include <iomanip>
int main() {
std::cout << "Default: " << 42 << std::endl;
std::cout << "Width 10: " << std::setw(10) << 42 << std::endl;
return 0;
}

复制代码

输出：

Default: 42
Width 10: 42

复制代码

设置填充字符

使用std::setfill可以设置填充字符：

#include <iostream>
#include <iomanip>
int main() {
std::cout << "Default fill: " << std::setw(10) << 42 << std::endl;
std::cout << "Custom fill: " << std::setw(10) << std::setfill('*') << 42 << std::endl;
return 0;
}

复制代码

输出：

Default fill: 42
Custom fill: ********42

复制代码

设置对齐方式

使用std::left和std::right可以设置左对齐和右对齐：

#include <iostream>
#include <iomanip>
int main() {
std::cout << "Right align (default): " << std::setw(10) << 42 << std::endl;
std::cout << "Left align: " << std::left << std::setw(10) << 42 << std::endl;
std::cout << "Right align again: " << std::right << std::setw(10) << 42 << std::endl;
return 0;
}

复制代码

输出：

Right align (default): 42
Left align: 42
Right align again: 42

复制代码

设置浮点数精度

使用std::setprecision可以设置浮点数的精度：

#include <iostream>
#include <iomanip>
int main() {
double pi = 3.141592653589793;
std::cout << "Default precision: " << pi << std::endl;
std::cout << "Precision 5: " << std::setprecision(5) << pi << std::endl;
std::cout << "Precision 10: " << std::setprecision(10) << pi << std::endl;
return 0;
}

复制代码

输出：

Default precision: 3.14159
Precision 5: 3.1416
Precision 10: 3.141592654

复制代码

设置浮点数表示法

使用std::fixed和std::scientific可以设置浮点数的表示法：

#include <iostream>
#include <iomanip>
int main() {
double value = 12345.6789;
std::cout << "Default: " << value << std::endl;
std::cout << "Fixed: " << std::fixed << value << std::endl;
std::cout << "Scientific: " << std::scientific << value << std::endl;
return 0;
}

复制代码

输出：

Default: 12345.7
Fixed: 12345.678900
Scientific: 1.234568e+04

复制代码

显示进制

使用std::dec、std::hex和std::oct可以设置整数的显示进制：

#include <iostream>
int main() {
int value = 42;
std::cout << "Decimal: " << std::dec << value << std::endl;
std::cout << "Hexadecimal: " << std::hex << value << std::endl;
std::cout << "Octal: " << std::oct << value << std::endl;
return 0;
}

复制代码

输出：

Decimal: 42
Hexadecimal: 2a
Octal: 52

复制代码

显示前缀

使用std::showbase可以显示进制前缀：

#include <iostream>
int main() {
int value = 42;
std::cout << std::showbase;
std::cout << "Decimal: " << std::dec << value << std::endl;
std::cout << "Hexadecimal: " << std::hex << value << std::endl;
std::cout << "Octal: " << std::oct << value << std::endl;
return 0;
}

复制代码

输出：

Decimal: 42
Hexadecimal: 0x2a
Octal: 052

复制代码

输出不同类型的数据

输出整数

#include <iostream>
int main() {
int decimal = 42;
long long largeNumber = 123456789012345LL;
unsigned int unsignedNumber = 42U;
std::cout << "Decimal: " << decimal << std::endl;
std::cout << "Large number: " << largeNumber << std::endl;
std::cout << "Unsigned: " << unsignedNumber << std::endl;
return 0;
}

复制代码

输出浮点数

#include <iostream>
#include <iomanip>
int main() {
float floatValue = 3.14f;
double doubleValue = 3.141592653589793;
long double longDoubleValue = 3.14159265358979323846L;
std::cout << "Float: " << floatValue << std::endl;
std::cout << "Double: " << doubleValue << std::endl;
std::cout << "Long double: " << longDoubleValue << std::endl;
// 设置精度
std::cout << std::setprecision(15);
std::cout << "Double with high precision: " << doubleValue << std::endl;
return 0;
}

复制代码

输出字符

#include <iostream>
int main() {
char ch = 'A';
std::cout << "Character: " << ch << std::endl;
// 输出字符的ASCII码
std::cout << "ASCII code: " << static_cast<int>(ch) << std::endl;
return 0;
}

复制代码

输出字符串

#include <iostream>
#include <string>
int main() {
// C风格字符串
const char* cString = "Hello, C-style string";
std::cout << "C-style string: " << cString << std::endl;
// C++ string对象
std::string cppString = "Hello, C++ string";
std::cout << "C++ string: " << cppString << std::endl;
return 0;
}

复制代码

输出布尔值

#include <iostream>
int main() {
bool flag = true;
std::cout << "Default bool output: " << flag << std::endl;
// 使用std::boolalpha输出文字形式
std::cout << "With boolalpha: " << std::boolalpha << flag << std::endl;
// 切换回数字形式
std::cout << "Without boolalpha: " << std::noboolalpha << flag << std::endl;
return 0;
}

复制代码

输出：

Default bool output: 1
With boolalpha: true
Without boolalpha: 1

复制代码

输出指针地址

#include <iostream>
int main() {
int value = 42;
int* ptr = &value;
std::cout << "Value: " << value << std::endl;
std::cout << "Address of value: " << &value << std::endl;
std::cout << "Pointer value: " << ptr << std::endl;
// 输出空指针
int* nullPtr = nullptr;
std::cout << "Null pointer: " << nullPtr << std::endl;
return 0;
}

复制代码

进阶技巧：更复杂的输出操作

输出表达式结果

可以直接输出表达式的结果：

#include <iostream>
int main() {
int a = 5, b = 3;
std::cout << "a + b = " << a + b << std::endl;
std::cout << "a - b = " << a - b << std::endl;
std::cout << "a * b = " << a * b << std::endl;
std::cout << "a / b = " << a / b << std::endl;
std::cout << "a % b = " << a % b << std::endl;
return 0;
}

复制代码

使用条件表达式输出

可以在输出语句中使用条件表达式：

#include <iostream>
int main() {
int score = 85;
std::cout << "The score is " << score << ", which is "
<< (score >= 60 ? "passing" : "failing") << std::endl;
return 0;
}

复制代码

输出函数返回值

可以直接输出函数的返回值：

#include <iostream>
#include <cmath>
int main() {
std::cout << "Square root of 16: " << std::sqrt(16) << std::endl;
std::cout << "Power of 2^3: " << std::pow(2, 3) << std::endl;
return 0;
}

复制代码

使用输出流操作符的优先级

需要注意<<操作符的优先级，有时需要使用括号：

#include <iostream>
int main() {
int a = 1, b = 2, c = 3;
// 错误：<<的优先级高于三元运算符
// std::cout << a > b ? a : b << std::endl; // 编译错误
// 正确：使用括号
std::cout << (a > b ? a : b) << std::endl;
// 错误：<<的优先级高于比较运算符
// std::cout << a << b < c << std::endl; // 编译错误
// 正确：使用括号
std::cout << a << (b < c) << std::endl;
return 0;
}

复制代码

自定义类型的输出：重载<<操作符

对于自定义类型，可以通过重载<<操作符来支持输出：

基本自定义类型输出

#include <iostream>
class Point {
private:
int x, y;
public:
Point(int x = 0, int y = 0) : x(x), y(y) {}
// 声明友元函数以重载<<操作符
friend std::ostream& operator<<(std::ostream& os, const Point& point);
};
// 重载<<操作符的实现
std::ostream& operator<<(std::ostream& os, const Point& point) {
os << "Point(" << point.x << ", " << point.y << ")";
return os;
}
int main() {
Point p1(3, 4);
Point p2(10, 20);
std::cout << "Point 1: " << p1 << std::endl;
std::cout << "Point 2: " << p2 << std::endl;
return 0;
}

复制代码

复杂自定义类型输出

#include <iostream>
#include <string>
#include <vector>
class Student {
private:
std::string name;
int id;
std::vector<double> grades;
public:
Student(const std::string& name, int id) : name(name), id(id) {}
void addGrade(double grade) {
grades.push_back(grade);
}
double getAverage() const {
if (grades.empty()) return 0.0;
double sum = 0.0;
for (double grade : grades) {
sum += grade;
}
return sum / grades.size();
}
// 声明友元函数以重载<<操作符
friend std::ostream& operator<<(std::ostream& os, const Student& student);
};
// 重载<<操作符的实现
std::ostream& operator<<(std::ostream& os, const Student& student) {
os << "Student[ID: " << student.id << ", Name: " << student.name << ", Grades: ";
if (student.grades.empty()) {
os << "None";
} else {
for (size_t i = 0; i < student.grades.size(); ++i) {
if (i > 0) os << ", ";
os << student.grades[i];
}
}
os << ", Average: " << student.getAverage() << "]";
return os;
}
int main() {
Student alice("Alice", 1001);
alice.addGrade(90.5);
alice.addGrade(85.0);
alice.addGrade(92.5);
Student bob("Bob", 1002);
bob.addGrade(78.0);
bob.addGrade(82.5);
std::cout << alice << std::endl;
std::cout << bob << std::endl;
return 0;
}

复制代码

继承体系中的输出操作符重载

#include <iostream>
#include <string>
class Shape {
protected:
std::string name;
public:
Shape(const std::string& name) : name(name) {}
virtual ~Shape() {}
virtual double area() const = 0;
// 声明友元函数以重载<<操作符
friend std::ostream& operator<<(std::ostream& os, const Shape& shape);
};
// 重载<<操作符的实现
std::ostream& operator<<(std::ostream& os, const Shape& shape) {
os << shape.name << " [Area: " << shape.area() << "]";
return os;
}
class Circle : public Shape {
private:
double radius;
public:
Circle(double radius) : Shape("Circle"), radius(radius) {}
double area() const override {
return 3.141592653589793 * radius * radius;
}
};
class Rectangle : public Shape {
private:
double width, height;
public:
Rectangle(double width, double height) : Shape("Rectangle"), width(width), height(height) {}
double area() const override {
return width * height;
}
};
int main() {
Circle circle(5.0);
Rectangle rectangle(4.0, 6.0);
std::cout << circle << std::endl;
std::cout << rectangle << std::endl;
return 0;
}

复制代码

常见问题和解决方案

问题1：输出缓冲区不及时刷新

问题描述：有时程序输出后，内容没有立即显示在屏幕上。

解决方案：使用std::endl或std::flush强制刷新缓冲区。

#include <iostream>
#include <chrono>
#include <thread>
int main() {
std::cout << "This will appear immediately";
std::cout << std::endl; // 刷新缓冲区
std::cout << "This will also appear immediately";
std::cout << std::flush; // 刷新缓冲区但不添加换行
std::cout << "This might not appear immediately...";
std::this_thread::sleep_for(std::chrono::seconds(2)); // 暂停2秒
std::cout << " until now." << std::endl;
return 0;
}

复制代码

问题2：输出格式混乱

问题描述：连续使用多个格式化操作符后，输出格式变得混乱。

解决方案：使用std::ios_base::fmtflags保存和恢复格式状态。

#include <iostream>
#include <iomanip>
int main() {
double value = 123.456789;
// 保存当前格式
std::ios_base::fmtflags originalFlags = std::cout.flags();
std::cout << "Default: " << value << std::endl;
// 修改格式
std::cout << std::fixed << std::setprecision(2);
std::cout << "Fixed with 2 decimals: " << value << std::endl;
// 恢复原始格式
std::cout.flags(originalFlags);
std::cout << "Restored to default: " << value << std::endl;
return 0;
}

复制代码

问题3：输出精度问题

问题描述：浮点数输出时精度不符合预期。

解决方案：正确使用std::setprecision和std::fixed/std::scientific。

#include <iostream>
#include <iomanip>
int main() {
double value = 123.456789;
// 默认精度（总位数）
std::cout << "Default precision: " << value << std::endl;
// 设置总位数
std::cout << "Precision 5: " << std::setprecision(5) << value << std::endl;
// 使用fixed表示法，设置小数位数
std::cout << "Fixed, precision 2: " << std::fixed << std::setprecision(2) << value << std::endl;
// 使用scientific表示法，设置小数位数
std::cout << "Scientific, precision 4: " << std::scientific << std::setprecision(4) << value << std::endl;
return 0;
}

复制代码

问题4：输出中文乱码

问题描述：在Windows系统上输出中文时出现乱码。

解决方案：设置控制台代码页或使用本地化。

#include <iostream>
#include <windows.h> // Windows API
int main() {
// 设置控制台代码页为UTF-8（Windows系统）
SetConsoleOutputCP(CP_UTF8);
std::cout << "你好，世界！" << std::endl;
std::cout << "C++编程中的输出操作符" << std::endl;
return 0;
}

复制代码

或者使用本地化：

#include <iostream>
#include <locale>
int main() {
// 设置本地化
std::locale::global(std::locale(""));
std::cout.imbue(std::locale());
std::cout << "你好，世界！" << std::endl;
std::cout << "C++编程中的输出操作符" << std::endl;
return 0;
}

复制代码

问题5：输出大量数据时性能低下

问题描述：输出大量数据时程序运行缓慢。

解决方案：减少缓冲区刷新次数，使用更高效的输出方法。

#include <iostream>
#include <fstream>
#include <chrono>
int main() {
const int N = 100000;
// 方法1：频繁刷新缓冲区（慢）
auto start = std::chrono::high_resolution_clock::now();
for (int i = 0; i < N; ++i) {
std::cout << i << std::endl; // 每次都刷新缓冲区
}
auto end = std::chrono::high_resolution_clock::now();
std::chrono::duration<double> elapsed = end - start;
std::cout << "Method 1 (frequent flush): " << elapsed.count() << " seconds\n";
// 方法2：减少刷新次数（快）
start = std::chrono::high_resolution_clock::now();
for (int i = 0; i < N; ++i) {
std::cout << i << "\n"; // 使用\n而不是endl，减少刷新
}
std::cout << std::flush; // 最后统一刷新
end = std::chrono::high_resolution_clock::now();
elapsed = end - start;
std::cout << "Method 2 (infrequent flush): " << elapsed.count() << " seconds\n";
// 方法3：使用文件输出（更快）
std::ofstream outFile("output.txt");
start = std::chrono::high_resolution_clock::now();
for (int i = 0; i < N; ++i) {
outFile << i << "\n";
}
outFile.close();
end = std::chrono::high_resolution_clock::now();
elapsed = end - start;
std::cout << "Method 3 (file output): " << elapsed.count() << " seconds\n";
return 0;
}

复制代码

性能优化和最佳实践

1. 减少缓冲区刷新

频繁刷新缓冲区会影响性能，尽量使用\n而不是std::endl，只在必要时刷新缓冲区。

// 不推荐（性能较差）
for (int i = 0; i < 1000; ++i) {
std::cout << i << std::endl; // 每次循环都刷新缓冲区
}
// 推荐（性能更好）
for (int i = 0; i < 1000; ++i) {
std::cout << i << "\n"; // 不刷新缓冲区
}
std::cout << std::flush; // 最后统一刷新

复制代码

2. 使用字符串拼接减少输出操作

多次小量输出比一次大量输出慢，可以考虑先拼接字符串再输出。

#include <iostream>
#include <sstream>
#include <string>
// 不推荐（多次输出）
void printInfo1(const std::string& name, int age, double score) {
std::cout << "Name: " << name << ", ";
std::cout << "Age: " << age << ", ";
std::cout << "Score: " << score << std::endl;
}
// 推荐（先拼接后输出）
void printInfo2(const std::string& name, int age, double score) {
std::ostringstream oss;
oss << "Name: " << name << ", Age: " << age << ", Score: " << score;
std::cout << oss.str() << std::endl;
}
int main() {
printInfo1("Alice", 20, 95.5);
printInfo2("Bob", 21, 88.0);
return 0;
}

复制代码

3. 使用格式化函数（C++20及以后）

C++20引入了std::format，提供了更高效、更安全的格式化方法：

#include <iostream>
#include <format> // C++20特性
int main() {
std::string name = "Alice";
int age = 30;
double score = 95.5;
// 使用std::format
std::string message = std::format("Name: {}, Age: {}, Score: {:.2f}", name, age, score);
std::cout << message << std::endl;
return 0;
}

复制代码

4. 避免不必要的格式化操作

格式化操作（如std::setw、std::setprecision等）会改变流的状态，如果不必要，应该避免使用。

#include <iostream>
#include <iomanip>
// 不推荐（不必要的格式化操作）
void printTable1() {
for (int i = 1; i <= 10; ++i) {
std::cout << std::setw(5) << i
<< std::setw(10) << i * i
<< std::setw(15) << i * i * i << std::endl;
}
}
// 推荐（减少格式化操作）
void printTable2() {
// 设置一次格式
std::cout << std::setw(5) << std::left;
for (int i = 1; i <= 10; ++i) {
std::cout << i << std::setw(10) << i * i
<< std::setw(15) << i * i * i << std::endl;
}
}
int main() {
std::cout << "Method 1:\n";
printTable1();
std::cout << "\nMethod 2:\n";
printTable2();
return 0;
}

复制代码

5. 使用输出迭代器

对于大量数据的输出，可以考虑使用输出迭代器：

#include <iostream>
#include <vector>
#include <iterator>
#include <algorithm>
int main() {
std::vector<int> data = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
// 使用输出迭代器输出容器内容
std::copy(data.begin(), data.end(), std::ostream_iterator<int>(std::cout, " "));
std::cout << std::endl;
return 0;
}

复制代码

实际应用示例

示例1：格式化输出表格

#include <iostream>
#include <iomanip>
#include <vector>
#include <string>
struct Product {
int id;
std::string name;
double price;
int quantity;
};
void printProductTable(const std::vector<Product>& products) {
// 设置表头
std::cout << std::left << std::setw(10) << "ID"
<< std::setw(25) << "Name"
<< std::setw(15) << "Price"
<< std::setw(10) << "Quantity" << std::endl;
// 设置分隔线
std::cout << std::string(60, '-') << std::endl;
// 设置固定和精度用于价格
std::cout << std::fixed << std::setprecision(2);
// 输出每个产品
for (const auto& product : products) {
std::cout << std::left << std::setw(10) << product.id
<< std::setw(25) << product.name
<< "$" << std::setw(14) << product.price
<< std::setw(10) << product.quantity << std::endl;
}
}
int main() {
std::vector<Product> products = {
{1001, "Laptop", 999.99, 10},
{1002, "Smartphone", 699.99, 25},
{1003, "Tablet", 349.99, 15},
{1004, "Headphones", 99.99, 50},
{1005, "Smartwatch", 199.99, 30}
};
printProductTable(products);
return 0;
}

复制代码

示例2：进度条显示

#include <iostream>
#include <chrono>
#include <thread>
void showProgressBar(int progress, int total) {
const int barWidth = 50;
float percentage = static_cast<float>(progress) / total;
std::cout << "[";
int pos = barWidth * percentage;
for (int i = 0; i < barWidth; ++i) {
if (i < pos) std::cout << "=";
else if (i == pos) std::cout << ">";
else std::cout << " ";
}
std::cout << "] " << int(percentage * 100.0) << " %\r";
std::cout.flush();
}
int main() {
int total = 100;
for (int i = 0; i <= total; ++i) {
showProgressBar(i, total);
std::this_thread::sleep_for(std::chrono::milliseconds(50));
}
std::cout << std::endl << "Process completed!" << std::endl;
return 0;
}

复制代码

示例3：日志输出系统

#include <iostream>
#include <string>
#include <chrono>
#include <iomanip>
#include <fstream>
enum class LogLevel {
DEBUG,
INFO,
WARNING,
ERROR
};
class Logger {
private:
std::ofstream logFile;
LogLevel currentLevel;
std::string levelToString(LogLevel level) {
switch (level) {
case LogLevel::DEBUG: return "DEBUG";
case LogLevel::INFO: return "INFO";
case LogLevel::WARNING: return "WARNING";
case LogLevel::ERROR: return "ERROR";
default: return "UNKNOWN";
}
}
std::string getCurrentTime() {
auto now = std::chrono::system_clock::now();
auto time_t = std::chrono::system_clock::to_time_t(now);
std::stringstream ss;
ss << std::put_time(std::localtime(&time_t), "%Y-%m-%d %H:%M:%S");
return ss.str();
}
public:
Logger(const std::string& filename, LogLevel level = LogLevel::INFO)
: currentLevel(level) {
logFile.open(filename, std::ios::app);
if (!logFile.is_open()) {
std::cerr << "Failed to open log file: " << filename << std::endl;
}
}
~Logger() {
if (logFile.is_open()) {
logFile.close();
}
}
void log(LogLevel level, const std::string& message) {
if (level < currentLevel) return;
std::string logEntry = "[" + getCurrentTime() + "] [" +
levelToString(level) + "] " + message;
// 输出到控制台
std::cout << logEntry << std::endl;
// 输出到文件
if (logFile.is_open()) {
logFile << logEntry << std::endl;
}
}
void setLevel(LogLevel level) {
currentLevel = level;
}
};
int main() {
Logger logger("app.log", LogLevel::DEBUG);
logger.log(LogLevel::DEBUG, "Application starting...");
logger.log(LogLevel::INFO, "User logged in");
logger.log(LogLevel::WARNING, "High memory usage detected");
logger.log(LogLevel::ERROR, "Failed to connect to database");
return 0;
}

复制代码

示例4：多线程安全输出

#include <iostream>
#include <thread>
#include <mutex>
#include <vector>
class ThreadSafeCout {
private:
static std::mutex mtx;
public:
template<typename T>
static ThreadSafeCout& operator<<(const T& value) {
std::lock_guard<std::mutex> lock(mtx);
std::cout << value;
return *this;
}
// 重载<<操作符以支持std::endl等操纵符
static ThreadSafeCout& operator<<(std::ostream& (*manip)(std::ostream&)) {
std::lock_guard<std::mutex> lock(mtx);
std::cout << manip;
return *this;
}
};
std::mutex ThreadSafeCout::mtx;
void worker(int id) {
for (int i = 0; i < 5; ++i) {
ThreadSafeCout{} << "Thread " << id << ": Count " << i << std::endl;
std::this_thread::sleep_for(std::chrono::milliseconds(100));
}
}
int main() {
std::vector<std::thread> threads;
// 创建多个线程
for (int i = 1; i <= 5; ++i) {
threads.emplace_back(worker, i);
}
// 等待所有线程完成
for (auto& thread : threads) {
thread.join();
}
return 0;
}

复制代码

总结

本教程详细介绍了C++编程中的输出操作符<<和cout的使用方法，从基础到高级，涵盖了以下关键内容：

1. 基础知识：理解cout对象和<<操作符的基本概念。
2. 基本用法：学习如何进行简单的输出操作，包括字符串输出、换行和链式输出。
3. 格式化输出：掌握如何控制输出的格式，包括宽度、填充字符、对齐方式、精度等。
4. 不同类型数据的输出：了解如何输出整数、浮点数、字符、字符串、布尔值和指针地址。
5. 进阶技巧：学习如何输出表达式结果、使用条件表达式、输出函数返回值以及处理操作符优先级问题。
6. 自定义类型的输出：掌握如何为自定义类型重载<<操作符，包括基本类型、复杂类型和继承体系中的类型。
7. 常见问题和解决方案：解决输出缓冲区不及时刷新、格式混乱、精度问题、中文乱码和性能低下等常见问题。
8. 性能优化和最佳实践：学习如何优化输出性能，包括减少缓冲区刷新、使用字符串拼接、使用格式化函数、避免不必要的格式化操作和使用输出迭代器。
9. 实际应用示例：通过格式化输出表格、显示进度条、实现日志输出系统和多线程安全输出等示例，展示如何在实际编程中应用所学知识。

通过本教程的学习，读者应该能够熟练掌握C++中的输出操作，解决实际编程中的输出挑战，并编写出高效、可读性强的输出代码。无论是简单的控制台输出还是复杂的格式化输出，都能够得心应手地处理。同时，通过性能优化和最佳实践的学习，读者还能够编写出更加高效的输出代码，提升程序的整体性能。

C++的输出操作符<<和cout对象是C++标准库中最基础、最常用的功能之一，掌握它们的使用对于C++编程至关重要。希望本教程能够帮助读者深入理解并灵活运用这些工具，提升C++编程的能力和效率。