C++常用标准库介绍

std::cout

std::cout是C++标准库中预定义的一个全局对象（注意不是类，是对象！），属于std::ostream类（输出流类）。使用cout可以将数据输出到控制台。

基本用法

#include <iostream>

int main() {
    std::cout << "Hello, World!" << std::endl;  // 输出字符串并换行
    return 0;
}

输出不同类型的数据

std::cout可以自动识别基本数据类型（如int，double，char，string等）。

    std::cout << "整数: " << num << std::endl;      // 输出：整数: 42
    std::cout << "浮点数: " << pi << std::endl;    // 输出：浮点数: 3.14159
    std::cout << "字符: " << ch << std::endl;       // 输出：字符: A
    std::cout << "字符串: " << str << std::endl;    // 输出：字符串: C++
    std::cout << "布尔值: " << flag << std:

控制输出格式

通过头文件中的函数，可以控制输出格式（如精度、字符宽度、进制等）。

常用格式控制符

• 设置宽度：std::setw(n)
  指定下一个输出项的最小宽度。std::setw只对下一个输出有效，之后恢复默认。
• 设置精度：std::setprecision(n)
  控制浮点数的小数位数。
• 填充字符：std::setfill©
  用字符 c 填充空白。
• 进制转换：std::hex、std::dec、std::oct
  分别以十六进制、十进制、八进制输出整数。

#include <iostream>
#include <iomanip>

int main() {
    int num = 255;
    double pi = 3.1415926535;
    // 设置宽度和填充字符
    std::cout << std::setw(10) << std::setfill('*') << num << std::endl;  // 输出：*******255
    std::cout << std::setw(10) << num << std::setfill('*') << std::endl;  // 输出：255*******
    // 设置浮点数精度
    std::cout << std::fixed << std::setprecision(2) << pi << std::endl;// 输出：3.14
    // 十六进制输出
    std::cout << std::hex << num << std::endl;  // 输出：ff
    // 布尔值显示为 true/false
    std::cout << std::boolalpha << true << std::endl;  // 输出：true
    return 0;
}

换行与刷新

• 换行符：std::endl
  插入换行符并刷新输出缓冲区。
• 刷新缓冲区：std::flush
  强制刷新缓冲区，但不换行。
• 仅换行：\n
  插入换行符，不强制刷新缓冲区。

刷新输出缓冲区是指强制将缓冲区中暂存的数据立即写入目标设备（如控制台、文件等），而不是等待缓冲区自然刷新（例如缓冲区填满、程序正常退出或遇到换行符）。这一机制确保了输出的即时性，尤其在需要实时查看结果时非常关键。那为什么要有缓冲区呢：

• 提高效率：频繁的系统调用（如写入控制台）代价较高，缓冲区将多次小数据操作合并为一次大的写入操作。
• 减少开销：批量处理数据能显著降低I/O操作的次数。

何时会自动刷新缓冲区？

1. 缓冲区已满。
2. 程序正常结束（main函数返回或调用exit()）。
3. 遇到换行符（如使用 std::endl）。
4. 输入操作（如使用 std::cin）可能触发关联输出流的刷新（交互式设备特性）。

std::bind

std::bind 是 C++ 标准库中的一个函数模板，用于创建一个绑定对象（std::function 对象），该对象可以将函数或成员函数与特定的参数绑定在一起。这使得你可以创建一个可调用对象，该对象在调用时会自动传递绑定的参数。

简单地说，C++引入std::bind可以简化调用某个对象的成员函数；自动传入固定参数给函数，简化了接口调用；可以封装更简单的回调函数接口。

基本用法

std::bind(F, A1, A2, ..., An, _1, _2, ..., _N);

• F：要绑定的函数或成员函数。
• A1, A2, …, An：直接传递给函数的参数。
• _1, _2, …, _N：占位符，表示将要传递的参数位置。
• 返回类型：std::function 对象

绑定普通函数示例代码

#include <iostream>
#include <functional>

// 定义一个普通函数
void myFunction(int a, int b, int c) {
    std::cout << "a: " << a << ", b: " << b << ", c: " << c << std::endl;
}

int main() {
    // 使用 std::bind 绑定普通函数
    std::function<void(int)> boundFunction = std::bind(myFunction, 10, std::placeholders::_1, 20);

    // 调用绑定的函数
    boundFunction(30);  // 输出: a: 10, b: 30, c: 20

    return 0;
}

绑定成员函数示例代码

绑定类成员函数时，bind的第二个参数传入对象指针或对象引用。

#include <iostream>
#include <functional>

class MyClass {
public:
    void myFunction(int a, int b, int c) {
        std::cout << "a: " << a << ", b: " << b << ", c: " << c << std::endl;
    }
};

int main() {
    MyClass obj;

    // 使用 std::bind 绑定成员函数
    std::function<void(int,int)> boundFunction = std::bind(&MyClass::myFunction, &obj, 10, std::placeholders::_1, std::placeholders::_2);

    // 调用绑定的函数
    boundFunction(20,30);  // 输出: a: 10, b: 20, c: 30

    return 0;
}

std::mutex

std::mutex 是 C++ 标准库中用于线程同步的互斥量（Mutual Exclusion）工具，用于保护共享资源，防止多个线程同时访问导致数据竞争。

声明和初始化

#include <mutex>
std::mutex mtx; //声明一个互斥量

核心方法

• lock()
  尝试获取锁。如果锁已被其他线程占用，当前线程会阻塞直到锁可用。

• unlock()
  释放锁。必须在 lock() 成功获取锁后调用，否则行为未定义。

• try_lock()
  尝试获取锁，不阻塞。若锁不可用，立即返回 false。

示例代码

#include <iostream>
#include <thread>
#include <mutex>

std::mutex mtx;
int shared_value = 0;

void increment() {
    for (int i = 0; i < 1000; ++i) {
        mtx.lock();            // 加锁
        ++shared_value;        // 临界区（Critical Section）
        mtx.unlock();          // 解锁
    	}
}
int main() {
    std::thread t1(increment);
    std::thread t2(increment);
    t1.join();
    t2.join();
    std::cout << "Final value: " << shared_value << std::endl;
    return 0;
}

注意：mutex需要手动调用unlock()接口释放锁，如果忘记释放会导致死锁。因此std::mutex经常使用RAII的std::lock_guard 或 std::unique_lock来管理锁。

std::lock_guard

std::lock_guard 是 C++ 标准库中用于管理互斥锁（std::mutex）的 RAII（Resource Acquisition Is Initialization）工具。它的核心作用是在构造时自动加锁，在析构时自动解锁，从而确保锁的正确释放，避免死锁或资源泄漏。它适用于简单且线程安全的代码场景，是推荐使用的锁管理方式。

声明和初始化

#include <mutex>
std::mutex mtx; //声明一个互斥量

std::function