C++ STL中20个关键组件代码案例

以下是C++ STL中一些关键组件及其相关算法的详细介绍和代码案例，详细说明和代码：

1. 容器（Containers）

• Vector 示例:

#include <vector>
std::vector<int> vec{1, 2, 3, 4, 5}; // 创建一个整数vector
vec.insert(vec.begin() + 2, 10); // 在索引2处插入元素10
vec.erase(vec.begin() + 1); // 删除第二个元素

• List 示例:

#include <list>
std::list<int> lst{1, 2, 3, 4, 5};
lst.splice(lst.begin(), lst, lst.end()); // 将末尾元素移动至开头
lst.remove(3); // 从list中移除所有等于3的元素

2. 算法（Algorithms）

• Sort 示例:

#include <algorithm>
std::vector<int> nums{5, 3, 2, 8, 1};
std::sort(nums.begin(), nums.end()); // 升序排序

• Find 示例:

int target = 3;
if (std::find(nums.begin(), nums.end(), target) != nums.end()) {
    std::cout << "Target found in the vector!\n";
}

• Copy 示例:

std::vector<int> dest(nums.size());
std::copy(nums.begin(), nums.end(), dest.begin()); // 拷贝nums到dest

3. 迭代器（Iterators）

• Reverse Iterator 示例:

for (auto rit = nums.rbegin(); rit != nums.rend(); ++rit) {
    std::cout << *rit << ' '; // 逆序输出vector的元素
}

4. 仿函数（Functors）和Lambda函数

• Lambda 示例:

std::sort(nums.begin(), nums.end(), [](const int &a, const int &b) {
    return a > b; // 降序排序
});

5. 容器适配器（Adapters）

• Stack 示例:

#include <stack>
std::stack<int, std::vector<int>> stk(vec); // 创建一个基于vector的栈
stk.push(6);
while (!stk.empty()) {
    std::cout << stk.top() << ' '; // 输出栈顶元素
    stk.pop();
}

6. 关联容器（Associative Containers）

• Map 示例:

#include <map>
std::map<std::string, int> m;
m["apple"] = 1; 
m["banana"] = 2;
for (const auto &pair : m) {
    std::cout << pair.first << ": " << pair.second << '\n'; // 输出键值对
}

7. 其他常用算法

• Erase-Remove Idiom 示例（移除满足条件的元素）:

nums.erase(std::remove(nums.begin(), nums.end(), 0), nums.end()); // 移除所有值为0的元素

8. 无序容器（Unordered Containers）

• Unordered Set 示例:

#include <unordered_set>
std::unordered_set<int> uset{1, 2, 3, 4, 5}; // 不保证元素顺序
if (uset.find(3) != uset.end()) {
    std::cout << "Element 3 exists in the set.\n";
}

• Unordered Map 示例:

#include <unordered_map>
std::unordered_map<std::string, int> umap;
umap["apple"] = 1;
umap["banana"] = 2;
for (const auto &entry : umap) {
    std::cout << entry.first << ": " << entry.second << '\n';
}

9. 生成器函数（Generator Functions）

C++11及以后版本引入了std::generate，用于生成一系列新的值。

std::vector<int> vec(10, 0); // 创建一个大小为10且初始值均为0的vector
std::iota(vec.begin(), vec.end(), 1); // 使用iota生成器将vector元素设置为1, 2, ..., 10

10. 双端队列（Deque）

• Deque 示例:

#include <deque>
std::deque<int> deq{1, 2, 3, 4, 5};
deq.push_front(0); // 在队列前端添加元素
deq.pop_back(); // 从队列尾部移除元素

11. 动态bitset（Dynamic Bitset）

std::bitset是定长的，如果需要动态调整大小，可以使用boost::dynamic_bitset（非STL标准，但在很多项目中广泛使用）。

12. 范围（Ranges）

C++20引入了范围概念，使得处理容器和迭代器更加简洁。例如，使用ranges版的std::sort:

#include <algorithm>
#include <ranges>

std::vector<int> nums{5, 3, 2, 8, 1};
std::ranges::sort(nums, std::greater<>{}); // 降序排序

13. 并行算法（Parallel Algorithms）

C++17引入了并行算法，利用多核处理器加速计算。例如，使用并行版的std::sort：

#include <algorithm>
#include <execution>

std::vector<int> nums{...};
std::sort(std::execution::par, nums.begin(), nums.end()); // 并行排序（需编译器支持）

14.智能指针（Smart Pointers）

在现代C++中，智能指针是用来管理内存自动释放的一种重要机制，避免了手动删除资源带来的问题，如内存泄漏。以下是几种常见的智能指针类型：

unique_ptr

std::unique_ptr 独占所有权，不允许复制，只能移动。当其生命周期结束时，它会自动释放所指向的对象。

std::unique_ptr<int> uptr(new int(10)); // 创建一个独占指针指向新创建的int

shared_ptr

std::shared_ptr 共享所有权，多个智能指针可以共享同一对象，引用计数决定何时释放对象。

std::shared_ptr<int> sptr1(new int(20));
std::shared_ptr<int> sptr2 = sptr1; // 复制构造，共享同一对象

weak_ptr

std::weak_ptr 是对 shared_ptr 的弱引用，不会增加对象的引用计数，主要用于解决循环引用问题。

std::shared_ptr<X> shared;
std::weak_ptr<X> weak = shared; // 弱引用不增加引用计数
if (auto locked = weak.lock()) { // 解锁弱引用检查对象是否还在
    // 使用locked
}

15. Lambda 表达式与函数对象

Lambda表达式允许在代码中定义匿名函数，常用于算法回调或其他需要临时函数的地方。

std::vector<int> vec = {1, 2, 3, 4, 5};
std::sort(vec.begin(), vec.end(), [](int a, int b) { return a > b; }); // 降序排列

16. 异常处理（Exception Handling）

C++通过try、catch和throw关键字来实现异常处理机制，捕获和处理程序运行时可能出现的问题。

try {
    throw std::runtime_error("An error occurred");
} catch (const std::exception& e) {
    std::cerr << "Caught exception: " << e.what() << '\n';
}

17. 进程间通信（IPC）与线程同步

虽然STL本身并不直接提供进程间通信或线程同步原语，但C++标准库中的<mutex>、<condition_variable>、<future>和<thread>等头文件提供了相关支持。

#include <mutex>
std::mutex mtx;
mtx.lock(); // 获取互斥锁
// ...访问/修改受保护的数据...
mtx.unlock(); // 释放互斥锁

// 线程同步示例
std::condition_variable cv;
std::mutex cv_mtx;
bool ready = false;

std::thread worker_thread([&]{
    std::unique_lock<std::mutex> lock(cv_mtx);
    cv.wait(lock, []{return ready;}); // 等待条件满足
    // ...工作线程被唤醒并执行后续任务...
});

// 主线程改变条件
{
    std::lock_guard<std::mutex> lock(cv_mtx);
    ready = true;
}
cv.notify_one(); // 唤醒等待的线程

worker_thread.join(); // 确保工作线程完成

18. 泛型编程（Generic Programming）

泛型编程是C++ STL的核心理念之一，通过模板（Template）技术实现了数据结构和算法的泛化。例如，std::vector<T>模板类可以存储任何类型的对象，只要该类型满足一定要求。

template<typename T>
class Vector {
public:
    void push_back(const T& item);
    // ...
private:
    std::size_t size_;
    T* data_;
};

19. 类型推导（Type Deduction）

C++11引入了类型推导的概念，尤其是在auto关键字和模板的上下文中。auto可以帮助我们省去显式类型声明，编译器会根据初始化表达式自动推断类型。

std::vector<int> vec = {1, 2, 3};
for (auto it = vec.begin(); it != vec.end(); ++it) {
    // 编译器会推断it的类型为std::vector<int>::iterator
}

20. C++17 新特性

• Structured Bindings：允许同时解构多个变量。

std::tuple<int, std::string> t = std::make_tuple(10, "Hello");
auto [num, word] = t; // num现在是int类型，word是std::string类型

• constexpr if：在编译期条件判断。

constexpr bool condition = /* some compile-time known value */;
if constexpr (condition) {
    // 如果condition为真，则这段代码将在编译时展开
} else {
    // 如果condition为假，则这段代码将在编译时忽略
}

• fold expressions：方便地处理初始化列表和折叠操作。

template<typename... Args>
void log_all(Args... args) {
    (std::cout << ... << args) << '\n'; // 折叠表达式，依次输出所有参数
}

log_all(1, 2, "three", 4.0f);

• std::optional：表示可能存在的值，避免空指针异常。

std::optional<int> maybe_num = get_number(); // 返回一个可能为空的int
if (maybe_num) {
    std::cout << *maybe_num << '\n'; // 若存在值则输出
}

请注意，上述代码仅为快速入门示例，实际使用时应考虑异常处理和边界检查等因素。C++ STL提供了许多其他实用功能和算法，如accumulate（累加）、find_if（根据条件查找元素）、transform（转换容器元素）等。通过深入了解和实践这些组件，您可以更加高效地编写高质量的C++代码。

以上内容展示了C++ STL的部分核心特性，实际上STL库还包含了更多实用工具和优化技巧，值得开发者深入学习和探索。

综上所述，C++ STL及现代C++特性为程序员提供了丰富的工具箱，使其能构建高效、安全且易于维护的软件系统。不断了解和熟悉这些特性，有助于提升编程技能，更好地应对各种复杂应用场景。
以上简要概述了C++的一些高级特性，实际开发中还有很多其他重要主题，包括模板元编程、RAII原则、类型traits等。

python推荐学习汇总连接：
50个开发必备的Python经典脚本(1-10)

50个开发必备的Python经典脚本(11-20)

50个开发必备的Python经典脚本(21-30)

50个开发必备的Python经典脚本(31-40)

50个开发必备的Python经典脚本(41-50)
————————————————

​最后我们放松一下眼睛