C++标准库：STL以及输入输出库，IO库，Cmath库，时间库，智能指针库与并发库等简介

• 标准库

C++ 标准库是 C++ 编程语言的核心部分，提供了丰富的功能和组件，包括容器、算法、迭代器、函数对象、智能指针、输入输出操作等。C++ 标准库主要包括以下几个组件：

1. STL（Standard Template Library）：STL 是 C++ 标准库的核心部分，包括容器、算法和迭代器。容器用于存储数据，如 vector、list、map 等；算法提供了各种通用算法，如排序、查找、遍历等；迭代器用于遍历容器中的元素。

2. 输入输出库：C++ 标准库提供了输入输出流类，用于实现输入输出操作。包括iostream、fstream、stringstream等类，可以实现对文件、标准输入输出流的读写操作。

3. 字符串处理库：C++ 标准库提供了丰富的字符串处理功能，包括string类、字符串流stringstream等，用于字符串的拼接、查找、替换等操作。

4. 数学库：C++ 标准库提供了数学函数库<cmath>，包括各种数学函数如三角函数、指数函数、对数函数等。

5. 时间库：C++ 标准库提供了时间处理功能，包括<chrono>头文件用于处理时间点和时间间隔，<ctime>头文件用于处理 C 风格的时间表示。

6. 智能指针库：C++11 引入了智能指针，包括std::shared_ptr、std::unique_ptr和std::weak_ptr，用于管理动态内存的所有权和生命周期。

7. 并发库：C++11 引入了并发编程的支持，包括线程库<thread>、互斥量<mutex>、条件变量<condition_variable>等，用于实现多线程编程。

8. 其他库：除上述几个主要组件外，C++ 标准库还包括其他功能模块，如异常处理、随机数生成、正则表达式等。

C++ 标准库的设计目标是提供高效、通用、可移植的功能组件，减少重复性开发，提高程序员的生产效率。标准库的组件之间有很好的协作性，可以灵活组合使用，满足不同的编程需求。

• STL

STL（Standard Template Library，标准模板库）是 C++ 标准库的核心部分，提供了丰富的通用数据结构和算法，用于实现各种常见的数据处理操作。STL 主要包括三个组件：容器（Containers）、算法（Algorithms）和迭代器（Iterators）。

容器（Containers）：

STL 中的容器是用于存储数据的数据结构，提供了各种不同类型的容器，如动态数组、链表、栈、队列、集合、映射等。常见的 STL 容器包括：

• 序列容器：vector（动态数组）、list（双向链表）、deque（双端队列）、array（固定大小数组）等。
• 关联容器：set（集合）、map（映射）、multiset（多重集合）、multimap（多重映射）等。
• 容器适配器：stack（栈）、queue（队列）、priority_queue（优先队列）等。

算法（Algorithms）：

STL 中的算法提供了各种通用算法，用于在容器中执行各种操作，如查找、排序、修改等。这些算法可以用于不同类型的容器，并且支持自定义函数对象来扩展功能。常见的 STL 算法包括：

• 查找算法：find、find_if、binary_search、count 等。
• 排序算法：sort、stable_sort、partial_sort 等。
• 修改算法：copy、transform、replace、fill 等。
• 数值算法：accumulate、inner_product、partial_sum 等。

迭代器（Iterators）：

迭代器是 STL 的核心概念，用于遍历容器中的元素，并提供统一的访问接口。迭代器将算法和容器解耦，使得算法可以独立于容器进行操作。STL 提供了不同类型的迭代器，包括输入迭代器、输出迭代器、前向迭代器、双向迭代器和随机访问迭代器。

STL 的设计思想是将数据结构和算法分离，提供通用的组件，使得开发人员可以快速、简单地实现各种数据处理操作。STL 中的组件之间有很好的兼容性和可组合性，可以灵活地搭配使用，满足不同的编程需求。 STL 的广泛应用使得 C++ 成为一种强大的编程语言，适用于各种应用场景。

• 输入输出库

C++ 标准库提供了丰富的输入输出流类，用于实现对不同数据源（如标准输入输出、文件、字符串等）的输入输出操作。输入输出流类主要包括iostream、fstream、stringstream等，每种类别都有特定的用途和功能。

1. iostream（标准输入输出流）：

iostream是 C++ 标准库中用于控制台输入输出操作的流类。它包括了istream（输入流）和ostream（输出流）两个基类，以及iostream（输入输出流）类。常见的iostream类有：

• cin：标准输入流，用于从控制台读取输入。
• cout：标准输出流，用于向控制台输出数据。
• cerr：标准错误流，用于向控制台输出错误信息。
• clog：标准日志流，用于向控制台输出日志信息。

#include <iostream>

int main() {
    int num;
    std::cout << "Enter a number: ";
    std::cin >> num;
    std::cout << "You entered: " << num << std::endl;
    return 0;
}

2. fstream（文件输入输出流）：

fstream是 C++ 标准库中用于文件输入输出操作的流类。它包括了ifstream（文件输入流）、ofstream（文件输出流）和fstream（文件输入输出流）三个类，用于读取和写入文件数据。

#include <fstream>

int main() {
    std::ofstream outFile("output.txt");
    if (outFile.is_open()) {
        outFile << "Hello, world!";
        outFile.close();
    }

    std::ifstream inFile("input.txt");
    if (inFile.is_open()) {
        std::string line;
        while (std::getline(inFile, line)) {
            std::cout << line << std::endl;
        }
        inFile.close();
    }
    return 0;
}

3. stringstream（字符串流）：

stringstream是 C++ 标准库中用于字符串流操作的类，可以方便地将字符串作为流来处理。它可以用于将数据转换为字符串或将字符串解析为数据。

#include <sstream>
#include <iostream>

int main() {
    std::stringstream ss;
    int num = 123;
    ss << "The number is: " << num;
    std::string result = ss.str();
    std::cout << result << std::endl;
    return 0;
}

以上是 C++ 标准库中输入输出流类的简要介绍，通过使用这些流类，可以实现对不同数据源的输入输出操作，包括控制台、文件和字符串等。这些流类提供了丰富的功能和灵活的接口，使得 C++ 编程更加方便和高效。

• 字符串处理库

C++ 标准库提供了丰富的字符串处理功能，包括string类、字符串流stringstream等，用于字符串的拼接、查找、替换等操作。下面详细介绍字符串处理库的主要组件以及使用方法：

1. std::string 类：

std::string 是 C++ 标准库中用于表示和处理字符串的类，提供了各种方法来操作字符串数据。常见的操作包括：

• 构造和赋值：可以通过构造函数、赋值运算符和字符串字面值来创建std::string对象。
• 访问和修改：可以使用下标访问、at()方法和迭代器来访问和修改字符串中的字符。
• 拼接：可以使用+运算符或append()方法来将字符串连接起来。
• 查找和替换：可以使用find()、rfind()、replace()等方法来查找和替换子字符串。
• 比较：可以使用==、<等运算符来比较字符串是否相等或大小。
• 转换：可以使用stoi()、stof()等函数将字符串转换为数字或其他类型。

#include <iostream>
#include <string>

int main() {
    std::string str1 = "Hello";
    std::string str2 = "World";

    std::string combined = str1 + " " + str2;
    std::cout << "Combined string: " << combined << std::endl;

    if (combined.find("World") != std::string::npos) {
        std::cout << "Found 'World' in the string." << std::endl;
    }

    combined.replace(6, 5, "C++");
    std::cout << "Replaced string: " << combined << std::endl;

    return 0;
}

2. std::stringstream 类：

std::stringstream 是 C++ 标准库中用于字符串流操作的类，可以方便地将字符串作为流来处理。它可以用于将数据转换为字符串或字符串解析为数据。

#include <iostream>
#include <sstream>

int main() {
    int num = 123;
    std::stringstream ss;
    ss << "The number is: " << num;

    std::string result = ss.str();
    std::cout << result << std::endl;

    std::stringstream ss2("10 20 30");
    int a, b, c;
    ss2 >> a >> b >> c;
    std::cout << "Parsed numbers: " << a << ", " << b << ", " << c << std::endl;

    return 0;
}

通过使用std::string类和std::stringstream类，可以方便地实现对字符串的各种操作，包括拼接、查找、替换、转换等。这些类提供了丰富的功能和灵活的接口，使得 C++ 字符串处理变得简单而高效。

• 数学库

C++ 标准库提供了数学库 <cmath>，包含了各种数学函数，如三角函数、指数函数、对数函数、幂函数、取整函数等，用于数学计算和处理。下面是数学库常用函数的介绍以及使用方法：

1. 常用数学函数：

• 三角函数：sin(), cos(), tan(), asin(), acos(), atan()
• 指数函数：exp(), log(), log10(), pow()
• 取整函数：ceil(), floor(), round()
• 绝对值函数：abs(), fabs()
• 平方根函数：sqrt()
• 随机数函数：rand(), srand()

2. 使用方法示例：

#include <iostream>
#include <cmath>
#include <cstdlib>
#include <ctime>

int main() {
    // 三角函数示例
    double angle = 45.0;
    double sine = sin(angle * M_PI / 180); // M_PI 是 π 的常量
    std::cout << "Sine of " << angle << " degrees: " << sine << std::endl;

    // 指数函数示例
    double base = 2.0;
    double exponent = 3.0;
    double power = pow(base, exponent);
    std::cout << base << " raised to the power of " << exponent << ": " << power << std::endl;

    // 随机数示例
    srand(time(0)); // 初始化随机数种子
    int randomNum = rand() % 100; // 生成 0 到 99 之间的随机数
    std::cout << "Random number: " << randomNum << std::endl;

    return 0;
}

通过包含 <cmath> 头文件，并使用其中提供的数学函数，可以在 C++ 程序中进行各种数学计算和处理。这些函数提供了丰富的数学功能，能够满足各种数学计算需求。在使用随机数函数时，需要注意初始化随机数种子，以确保每次运行程序时产生的随机数不同。

• 时间库

C++ 标准库中的时间库主要包括 <chrono> 头文件，用于处理时间点（time points）和时间间隔（durations）。通过时间库，可以进行时间的计算、比较和转换，以及实现定时操作和时间相关的功能。下面是时间库的主要内容以及应用示例：

1. 时间点（time points）：

• std::chrono::time_point：表示特定时钟上的时间点，可以精确到纳秒级别。
• 时钟类型：不同的时钟类型（std::chrono::system_clock、std::chrono::steady_clock、std::chrono::high_resolution_clock）提供不同的精度和稳定性。

2. 时间间隔（durations）：

• std::chrono::duration：表示时间的间隔，可以以不同的时间单位（秒、毫秒、微秒、纳秒等）表示。
• std::chrono::duration_cast：用于时间间隔之间的单位转换。

3. 应用示例：

#include <iostream>
#include <chrono>
#include <thread>

int main() {
    // 获取当前时间点
    auto start = std::chrono::high_resolution_clock::now();

    // 模拟耗时操作
    std::this_thread::sleep_for(std::chrono::seconds(2));

    // 获取耗时时长
    auto end = std::chrono::high_resolution_clock::now();
    auto duration = std::chrono::duration_cast<std::chrono::milliseconds>(end - start);

    // 输出耗时时长
    std::cout << "Operation took " << duration.count() << " milliseconds." << std::endl;

    return 0;
}

在上面的示例中，我们使用 <chrono> 头文件中的时间库来测量一个耗时操作的执行时间。首先，我们获取操作开始时的时间点，然后使用 std::this_thread::sleep_for 模拟一个持续 2 秒的耗时操作。最后，我们获取操作结束的时间点，并计算出操作的耗时时长，以毫秒为单位输出到控制台。

时间库在实际应用中经常用于性能分析、定时操作、超时控制等场景。通过精确测量时间点和时间间隔，可以帮助开发人员优化程序性能、控制程序运行时间，并实现时间相关的功能需求。

• 智能指针库

C++11 引入了智能指针（Smart Pointers）来管理动态分配的内存，避免内存泄漏和悬空指针等问题。智能指针是一种 RAII（资源获取即初始化）的技术，可以在指针生命周期结束时自动释放内存。C++ 标准库提供了三种主要的智能指针：std::unique_ptr、std::shared_ptr 和 std::weak_ptr。以下是每种智能指针的详细介绍及用法示例：

1. std::unique_ptr：

• std::unique_ptr 用于独占拥有动态分配的对象，保证只有一个指针可以指向该对象。
• 当 std::unique_ptr 离开作用域时，它所指向的对象会被自动释放。
• 不能对同一个对象拥有多个 std::unique_ptr。

用法示例：

#include <memory>
#include <iostream>

int main() {
    std::unique_ptr<int> uniquePtr(new int(42));
    
    std::cout << *uniquePtr << std::endl;

    // uniquePtr 离开作用域后，动态分配的内存会被自动释放
    return 0;
}

2. std::shared_ptr：

• std::shared_ptr 允许多个指针共享对同一个对象的拥有权，通过引用计数来管理对象的内存。
• 当最后一个 std::shared_ptr 离开作用域时，对象的内存会被释放。
• 可以通过 std::make_shared 来创建 std::shared_ptr。

用法示例：

#include <memory>
#include <iostream>

int main() {
    std::shared_ptr<int> sharedPtr = std::make_shared<int>(42);
    
    std::cout << *sharedPtr << std::endl;

    // 可以通过拷贝构造函数创建多个 sharedPtr
    auto sharedPtr2 = sharedPtr;

    // 最后一个 sharedPtr 离开作用域后，动态分配的内存会被自动释放
    return 0;
}

3. std::weak_ptr：

• std::weak_ptr 是 std::shared_ptr 的弱引用，不会增加引用计数，不影响对象的生命周期。
• 通常用于解决 std::shared_ptr 循环引用问题。

用法示例：

#include <memory>
#include <iostream>

int main() {
    std::shared_ptr<int> sharedPtr = std::make_shared<int>(42);
    std::weak_ptr<int> weakPtr = sharedPtr;

    // 使用 lock() 方法获取 shared_ptr 对象
    if (auto shared = weakPtr.lock()) {
        std::cout << *shared << std::endl;
    } else {
        std::cout << "sharedPtr is expired" << std::endl;
    }

    return 0;
}

通过使用智能指针，可以避免手动管理动态内存分配的问题，有效地提高代码的可维护性和安全性。在选择使用哪种智能指针时，需要根据具体的需求和所有权关系来决定。

• 并发库

C++ 标准库提供了一套并发库，包括 <thread>、<mutex>、<condition_variable> 等头文件，用于支持多线程编程和实现线程间的同步与通信。下面详细介绍并发库的主要组件以及使用方法：

1. <thread> 头文件：

• std::thread 类用于创建和管理线程，可以执行指定的函数或函数对象。
• std::this_thread::get_id() 可以获取当前线程的 ID。

用法示例：

#include <iostream>
#include <thread>

void threadFunction() {
    std::cout << "Hello from thread!" << std::endl;
}

int main() {
    std::thread t(threadFunction);
    
    std::cout << "Hello from main thread!" << std::endl;

    t.join(); // 等待线程 t 执行完毕

    return 0;
}

2. <mutex> 头文件：

• std::mutex 类用于提供互斥锁，保护共享资源的访问，防止多个线程同时访问造成数据竞争。
• std::lock_guard<std::mutex> 是一个 RAII 封装，用于自动管理互斥锁的上锁和解锁。

用法示例：

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

std::mutex mtx;

void threadFunction() {
    std::lock_guard<std::mutex> lock(mtx);
    std::cout << "Hello from thread!" << std::endl;
}

int main() {
    std::thread t(threadFunction);
    
    {
        std::lock_guard<std::mutex> lock(mtx);
        std::cout << "Hello from main thread!" << std::endl;
    }

    t.join();

    return 0;
}

3. <condition_variable> 头文件：

• std::condition_variable 类用于在多线程间进行条件变量的同步，配合互斥量使用。
• wait(), notify_one(), notify_all() 用于条件变量的等待和唤醒操作。

用法示例：

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

std::mutex mtx;
std::condition_variable cv;
bool ready = false;

void threadFunction() {
    std::unique_lock<std::mutex> lock(mtx);
    cv.wait(lock, [](){ return ready; });
    std::cout << "Hello from thread!" << std::endl;
}

int main() {
    std::thread t(threadFunction);
    
    {
        std::lock_guard<std::mutex> lock(mtx);
        ready = true;
    }
    cv.notify_one();

    t.join();

    return 0;
}

通过使用 <thread>、<mutex>、<condition_variable> 等并发库头文件，可以实现多线程编程，实现线程的创建、同步和通信等操作。合理地使用这些组件可以帮助我们编写高效、安全的多线程程序，避免数据竞争和死锁等问题。