C++开发必备之stl进阶（三高级操作）

已于 2024-09-18 14:12:49 修改
阅读量2k 收藏 27
点赞数 67
分类专栏： IT生涯 文章标签： c++ 开发语言
于 2024-09-18 00:15:00 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/scm06111/article/details/142313472
版权

C++ 标准模板库（STL）提供了强大的容器、迭代器和算法，能够帮助开发者编写高效、可重用的代码。在基础使用之上，STL 还提供了一些高级用法，使得我们可以编写出更灵活和高效的代码。以下是一些 STL 的高级使用技巧和方法。

1. STL 容器的自定义比较函数

在 STL 的有序容器中（如 std::set、std::map），可以通过自定义比较函数来定义容器的排序规则。

示例：自定义 std::set 的比较规则
#include <iostream>
#include <set>

// 自定义比较函数，按绝对值大小排序
struct Compare {
    bool operator()(int a, int b) const {
        return abs(a) < abs(b);
    }
};

int main() {
    std::set<int, Compare> s = { -3, 2, -1, 5, -4 };

    for (const auto& elem : s) {
        std::cout << elem << " ";  // 输出: -1 2 -3 -4 5
    }
    return 0;
}

2. Lambda 表达式与 STL 算法结合

C++11 引入了 Lambda 表达式，使得我们可以更加灵活地将自定义的逻辑嵌入到 STL 算法中，如 std::sort、std::find_if 等。

示例：使用 Lambda 表达式自定义排序
#include <iostream>
#include <vector>
#include <algorithm>

int main() {
    std::vector<int> vec = { 5, 3, 1, 4, 2 };

    // 按绝对值降序排序
    std::sort(vec.begin(), vec.end(), [](int a, int b) {
        return abs(a) > abs(b);
    });

    for (int i : vec) {
        std::cout << i << " ";  // 输出: 5 4 3 2 1
    }
    return 0;
}

示例：使用 Lambda 表达式查找特定元素

#include <iostream>
#include <vector>
#include <algorithm>

int main() {
    std::vector<int> vec = { 1, 2, 3, 4, 5 };

    // 查找第一个大于 3 的元素
    auto it = std::find_if(vec.begin(), vec.end(), [](int x) {
        return x > 3;
    });

    if (it != vec.end()) {
        std::cout << "First element greater than 3: " << *it << std::endl;  // 输出: 4
    }
    return 0;
}

3. 使用 std::transform 进行元素变换

std::transform 是 STL 中的一个强大算法，用于将一组元素转换为另一组元素。可以使用 Lambda 表达式或函数指针来定义转换规则。

示例：对容器中的每个元素进行平方
#include <iostream>
#include <vector>
#include <algorithm>

int main() {
    std::vector<int> vec = { 1, 2, 3, 4, 5 };
    std::vector<int> result(vec.size());

    // 对每个元素平方
    std::transform(vec.begin(), vec.end(), result.begin(), [](int x) {
        return x * x;
    });

    for (int i : result) {
        std::cout << i << " ";  // 输出: 1 4 9 16 25
    }
    return 0;
}

4. 使用 std::accumulate 进行聚合操作

std::accumulate 是一个很有用的算法，用于对容器中的元素进行聚合操作，例如求和、求积或自定义聚合。

示例：使用 std::accumulate 求和
#include <iostream>
#include <vector>
#include <numeric>

int main() {
    std::vector<int> vec = { 1, 2, 3, 4, 5 };

    int sum = std::accumulate(vec.begin(), vec.end(), 0);
    std::cout << "Sum: " << sum << std::endl;  // 输出: 15

    return 0;
}

示例：使用 std::accumulate 进行字符串连接

#include <iostream>
#include <vector>
#include <numeric>
#include <string>

int main() {
    std::vector<std::string> words = { "Hello", "World", "!" };

    std::string sentence = std::accumulate(words.begin(), words.end(), std::string(""), 
                                           [](const std::string& a, const std::string& b) {
                                               return a + (a.length() > 0 ? " " : "") + b;
                                           });

    std::cout << "Sentence: " << sentence << std::endl;  // 输出: Hello World !
    return 0;
}

5. 使用 std::copy 和 std::copy_if 进行容器拷贝

std::copy 用于将容器的元素拷贝到另一个容器，而 std::copy_if 则可以根据条件拷贝部分元素。

示例：使用 std::copy_if 复制符合条件的元素
#include <iostream>
#include <vector>
#include <algorithm>

int main() {
    std::vector<int> vec = { 1, 2, 3, 4, 5 };
    std::vector<int> result;

    // 复制所有大于 3 的元素
    std::copy_if(vec.begin(), vec.end(), std::back_inserter(result), [](int x) {
        return x > 3;
    });

    for (int i : result) {
        std::cout << i << " ";  // 输出: 4 5
    }
    return 0;
}

6. 使用 std::partition 和 std::stable_partition 进行容器分割

std::partition 可以将容器中的元素按某个条件进行分割，使得符合条件的元素排列在前，不符合条件的元素排列在后。

示例：将偶数和奇数分开
#include <iostream>
#include <vector>
#include <algorithm>

int main() {
    std::vector<int> vec = { 1, 2, 3, 4, 5 };

    // 将偶数放在前面，奇数放在后面
    std::partition(vec.begin(), vec.end(), [](int x) {
        return x % 2 == 0;
    });

    for (int i : vec) {
        std::cout << i << " ";  // 输出: 2 4 3 1 5 (偶数在前)
    }
    return 0;
}

7. 使用 std::unique 删除容器中的重复元素

std::unique 用于消除相邻的重复元素，常与 std::sort 结合使用以删除非相邻的重复元素。

示例：删除相邻的重复元素
#include <iostream>
#include <vector>
#include <algorithm>

int main() {
    std::vector<int> vec = { 1, 1, 2, 2, 3, 3, 4, 4 };

    auto it = std::unique(vec.begin(), vec.end());
    vec.erase(it, vec.end());

    for (int i : vec) {
        std::cout << i << " ";  // 输出: 1 2 3 4
    }
    return 0;
}

8. 使用 std::lower_bound 和 std::upper_bound 查找有序容器中的范围

  • std::lower_bound：返回第一个不小于给定值的元素的位置。
  • std::upper_bound：返回第一个大于给定值的元素的位置。
示例：查找有序数组中的范围
#include <iostream>
#include <vector>
#include <algorithm>

int main() {
    std::vector<int> vec = { 1, 2, 4, 4, 4, 5, 6 };

    auto lower = std::lower_bound(vec.begin(), vec.end(), 4);
    auto upper = std::upper_bound(vec.begin(), vec.end(), 4);

    std::cout << "Lower bound for 4: " << (lower - vec.begin()) << std::endl;  // 输出: 2
    std::cout << "Upper bound for 4: " << (upper - vec.begin()) << std::endl;  // 输出: 5

    return 0;
}

9. 智能指针与 STL 结合

STL 容器可以与智能指针很好地结合使用，从而避免手动管理内存。例如，使用 std::shared_ptr 或 std::unique_ptr 存储对象，容器会自动处理对象的生命周期。

示例：std::vector 中使用 std::shared_ptr
#include <iostream>
#include <memory>
#include <vector>

class Foo {
public:
    Foo(int value) : value_(value) {
        std::cout << "Constructing Foo(" << value_ << ")" << std::endl;
    }
    ~Foo() {
        std::cout << "Destructing Foo(" << value_ << ")" << std::endl;
    }

    int getValue() const { return value_; }

private:
    int value_;
};

int main() {
    std::vector<std::shared_ptr<Foo>> vec;

    vec.push_back(std::make_shared<Foo>(1));
    vec.push_back(std::make_shared<Foo>(2));
    vec.push_back(std::make_shared<Foo>(3));

    for (const auto& fooPtr : vec) {
        std::cout << "Foo value: " << fooPtr->getValue() << std::endl;
    }

    return 0;
}

在这个例子中，std::shared_ptr 自动管理了 Foo 对象的生命周期，容器销毁时对象也会被正确释放。

10. 高效的哈希容器

C++11 引入了 std::unordered_set 和 std::unordered_map，它们是基于哈希表的容器，提供了 O(1) 平均时间复杂度的查找、插入和删除操作。

示例：std::unordered_map 的使用
#include <iostream>
#include <unordered_map>
#include <string>

int main() {
    std::unordered_map<std::string, int> umap;

    umap["apple"] = 5;
    umap["banana"] = 2;
    umap["orange"] = 4;

    // 遍历 unordered_map
    for (const auto& pair : umap) {
        std::cout << pair.first << ": " << pair.second << std::endl;
    }

    // 查找元素
    if (umap.find("banana") != umap.end()) {
        std::cout << "Found banana, quantity: " << umap["banana"] << std::endl;
    }

    return 0;
}

11. 并行算法（C++17）

C++17 引入了并行 STL 算法，通过添加并行执行策略可以利用多核处理器并行执行算法。std::sort 等常见算法可以通过并行执行策略显著加速。

示例：并行 std::sort
#include <iostream>
#include <vector>
#include <algorithm>
#include <execution>  // C++17 并行执行策略

int main() {
    std::vector<int> vec = {5, 3, 1, 4, 2};

    // 使用并行执行策略排序
    std::sort(std::execution::par, vec.begin(), vec.end());

    for (int i : vec) {
        std::cout << i << " ";  // 输出: 1 2 3 4 5
    }

    return 0;
}

12. 使用 std::tuple 存储多种类型

std::tuple 是 C++11 引入的一种可以存储多个不同类型对象的容器，非常适合函数返回多个值或需要存储多种类型的数据。

示例：使用 std::tuple 返回多个值
#include <iostream>
#include <tuple>

std::tuple<int, double, std::string> getValues() {
    return std::make_tuple(42, 3.14, "Hello");
}

int main() {
    auto [i, d, s] = getValues();  // C++17 解构绑定

    std::cout << "Integer: " << i << ", Double: " << d << ", String: " << s << std::endl;
    return 0;
}

在这个例子中，std::tuple 用于返回多个不同类型的值，并通过 C++17 的结构化绑定直接解构返回值。

13. std::optional 处理可能不存在的值

C++17 引入了 std::optional，用于表示一个值可能存在或不存在。这在处理函数返回值或处理空值时非常有用。

示例：使用 std::optional
#include <iostream>
#include <optional>

std::optional<int> getValue(bool condition) {
    if (condition) {
        return 42;
    } else {
        return std::nullopt;  // 表示没有值
    }
}

int main() {
    auto value = getValue(true);
    if (value) {
        std::cout << "Value: " << *value << std::endl;
    } else {
        std::cout << "No value" << std::endl;
    }

    return 0;
}

挨踢小明
关注
专栏目录
C++从入门到进阶的系列书籍推荐（22本书）
dvlinker的技术专栏
11-05 3万+
要多读书，读好书！一本书要多读几遍才好，每次都可能有新的收获！特别在是有一定的工作年限和工作经验之后！读书百遍，其义自见！ 下面就给大家推荐一下C++程序员进阶需要读的经典书籍： 1、C++入门书籍 C++是在C语言的基础上发展而来的，要学习C++之前需要先学习C语言。有了C语言基础之后再去学习C++。 1.1、C语言程序设计（谭浩强） 该书被公认为学习C语言程序设计的优秀教材，被全国大多数高校选用，是学习C语言的主流用书。本书比较通俗易懂，是初入者必备的书籍。 ........
C++ 应用软件开发从入门到精通详解
热门推荐
dvlinker的技术专栏
06-21 3万+
本文详细介绍一下Windows平台下用C++开发应用软件的诸多内容，以供大家借鉴或参考。
C++开发必备之stl进阶（四deque）
09-18 761
（双端队列，Double-ended Queue）是 C++ 标准模板库（STL）中的一种序列容器，允许在两端（前端和后端）高效地插入和删除元素。支持在容器的头部和尾部同时进行高效的插入和删除操作，而。在头部插入元素时效率较低，因为它需要移动所有元素。提供了多种操作来支持在头部和尾部插入和删除元素。提供了一些方法来检查容器的大小、是否为空等。支持迭代器，可以使用标准的迭代器操作来遍历。也支持常数时间的随机访问，使用下标运算符。允许在任意位置插入或删除元素，使用。来访问特定位置的元素。
C++开发必备之stl进阶（七 队列）
09-18 263
是标准模板库（STL）中的容器适配器，遵循**先进先出（FIFO，First In First Out）**的原则。是 C++ 标准模板库中的容器适配器，旨在实现先进先出（FIFO，First In First Out）的队列数据结构。返回队列头部元素的引用（不删除该元素），可以通过它来访问或修改头部的元素。本身并不是一个独立的容器，它是一种容器适配器，基于底层容器来实现其功能。）包装成队列的形式，提供了头部出队、尾部入队的接口。相似，但它返回的是队列中的最后一个元素。返回队列尾部元素的引用，和。
C++开发必备之stl进阶（五 优先队列）
09-18 318
可以通过自定义比较函数来定义复杂类型的优先级队列。例如，假设我们有一个。
C++开发必备之stl进阶（六 栈）
09-18 269
是标准模板库（STL）中的容器适配器，遵循**后进先出（LIFO，Last In First Out）**的原则。是一个容器适配器，它限制了底层容器的操作，仅提供对栈的基本操作接口。移除栈顶元素，注意此操作并不会返回被移除的元素，若需要访问栈顶元素可以先调用。我们可以使用栈将整数中的每一位压入栈中，然后按顺序弹出，以实现整数反转。本质上是一个容器适配器，它封装了一个底层容器，默认情况下底层容器是。返回栈顶元素的引用（不删除），可以通过它来访问或修改栈顶的元素。的一个完整示例，它展示了栈的基本操作。
C++开发必备之stl进阶（八 unordered_map）
09-18 957
假设我们有一个自定义类型作为键，需要自定义哈希函数。int x;int y;// 自定义哈希函数return 0;如果需要不同的键比较逻辑，可以通过提供自定义比较函数来实现。然而，对于，键比较函数需要用于处理哈希冲突时键的相等性判断，通常不需要修改，除非有特殊需求。当使用自定义类型作为键时，需要自定义哈希函数和键比较函数。// 自定义键类型int age;// 自定义哈希函数return 0;有时需要对数据进行分区或分组，可以结合使用和算法。
[C++ 系列] 88. STL进阶及简单总结
Y-puyu 的博客
03-19 710
文章目录1. STL的本质2. STL的六大组件2.1 容器2.2 算法2.3 迭代器2.3.1 什么是迭代器2.3.2 为什么需要迭代器2.3.3 迭代器应该由谁负责提供2.3.4 迭代器实现原理2.3.5 迭代器与类的融合2.3.6 反向迭代器2.3.7 迭代器萃取(了解)2.4 适配器2.5 仿函数2.6 空间配置器3. STL框架 1. STL的本质 通过前面的学习以及使用，我们对 STL...
【C++】蓝桥杯必备 算法竞赛常用STL万字总结
CPT1024
03-15 3万+
C++ STL标准库 常用函数总结 算法竞赛必备
C++开发工程师高级进阶课程-提升C++面试和开发能力.zip
01-20
《C++开发工程师高级进阶课程-提升C++面试和开发能力》的资源包，旨在帮助C++开发者进一步提升自己的专业技能，以适应更高级别的面试挑战和开发工作。这份资料集涵盖了C++语言的核心知识，包括但不限于C++面试常见...
C++进阶STL适配器总结1
08-08
在C++编程中，STL（Standard Template Library，标准模板库）是不可或缺的一部分，它...理解它们的工作原理并知道何时使用，是C++程序员必备的技能之一。通过灵活运用这些工具，可以编写出更加高效且易于维护的代码。
C++，STL 028（24.10.11）
Erif_Liu的博客
10-12 237
利用sort排序算法来对deque容器进行排序。
如何用c++模拟创建用户（只得创建一个用户）
2301_78863827的博客
10-14 774
模拟系列，希望大家能多提意见
C语言内存函数
L73S37的博客
10-13 446
对于重叠内存，用memmove来实现。
【C语言】指针与函数：传值与传址
最新发布
我的我的博客
10-17 487
函数在使用的时候，给到的形式参数属于局部变量，仅在函数体内部有效。 1. 传值，对于两个值的交换，不影响函数调用之前的数值。这个就是传值，传递的是实参。 2. 传址，如果想通过函数来改变原本两个变量的值，那么需要传递地址。 3. 另外一种方式就是定义**全局变量**，参数不进行传递。可以直接实现在自定义函数体内，改变main函数中、或者其他函数中的值。
C++文档数据保存与解析
一个大佬的博客
10-12 357
【代码】C++文档数据保存与解析。
C++ 中的自旋锁应用：SpinLockManual、SpinLockGuard 和 SpinLockTryGuard
极地星辰
10-13 342
在多线程编程中，同步机制是确保线程安全的关键。自旋锁（Spin Lock）是一种常见的同步机制，它通过忙等待（busy-waiting）的方式来实现线程间的互斥访问。在 C++ 中，我们可以使用 `std::atomic_flag` 来实现自旋锁。本文将介绍如何使用 `SpinLockManual`、`SpinLockGuard` 和 `SpinLockTryGuard` 这三个类来应用自旋锁。
learn C++ NO.23——map、set的模拟实现
sinzz的博客
10-13 1008
本篇文章以STL库为模板，模拟实现了map和set。实现了map和set的跌打器部分以及map的operator[]。通过封装一份简易版本的map和set，学习库的设计者的设计思路，以到达更好的理解map和set。
C++ 的存储类型与新的 thread_local
oRbIt 的专栏
10-14 673
存储周期只是一个概念，是程序语义范畴内的东西，但不是语法的范畴。存储类型说明符也被称为存储类型，它们是变量声明语法中类型说明符的一部分，它们和变量名的范围一起控制变量的两个独立属性，即存储周期和链接属性。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值