1. 项目概述：从“会用”到“用好”STL容器

在C++的日常开发里，STL（Standard Template Library，标准模板库）的容器，就像木匠手里的锤子和凿子，是基础得不能再基础的工具。你随便翻翻招聘要求或者面试题，“熟悉STL”几乎是标配。但“熟悉”这个词很有意思，很多人可能止步于知道 vector 能动态数组、 map 能存键值对，面试前背一背迭代器失效的“八股文”。然而，真正在项目里，尤其是性能敏感或者逻辑复杂的场景下，这种程度的“熟悉”往往不够用，一个错误的选择或不经意的用法，就可能埋下内存泄漏、性能瓶颈甚至难以追踪的Bug。

这个实战系列，我不想再重复那些教科书上的定义和简单的 push_back 、 find 操作。我们直接切入核心： 面对一个具体的问题，如何从STL的“武器库”里选出最趁手的那把“武器”，以及在使用时，如何避开那些教科书不提、但老手常踩的“坑” 。比如，当你需要频繁在头部插入数据时，为什么 deque 通常比 vector 更合适？ map 的 [] 运算符和 insert 方法在行为上有何微妙差异，这差异又会导致什么后果？ vector 的 reserve 和 resize ，一字之差，底层内存和对象生命周期管理天差地别。

我们的目标不是记住所有容器的API，而是建立起一套选择和使用容器的“肌肉记忆”和“条件反射”。通过剖析几个贴近实战的基础案例，我们把 vector 、 deque 、 list 、 map / set 、 unordered_map / unordered_set 这些常用容器，放到具体的问题场景中，看看它们各自的表现，理解其背后的数据结构（如数组、链表、红黑树、哈希表）如何决定了它们的特性。最终，让你在写代码时，能自信地说出：“这里用 unordered_map ，因为我们需要O(1)的查找，且不关心顺序”，而不是“好像 map 也可以，先试试看”。

2. 容器选型核心思路：理解数据结构是根本

很多初学者选择容器靠感觉，或者哪个名字熟用哪个。这是效率低下和潜在风险的根源。STL容器的行为差异，根源在于其底层实现的数据结构。选型的第一步，永远是分析你的核心操作需求。

2.1 核心操作需求分析

你需要问自己几个关键问题：

  1. 插入/删除的主要位置在哪？ 尾部、头部还是任意位置？
  2. 是否需要频繁的随机访问？ 即通过下标（如 [i] ）快速获取元素。
  3. 元素的顺序是否重要？ 是必须保持插入顺序，还是需要自动排序，或者根本不在乎顺序？
  4. 查找是否是关键操作？ 如果需要频繁根据某个“键”查找对应的“值”，查找效率就是首要考量。
  5. 内存布局和缓存友好性是否重要？ 对于极高性能要求的场景，连续内存带来的缓存命中率提升可能是决定性的。

基于这些问题的答案，我们可以绘制一个简单的决策流，但更重要的是理解其背后的原因。

2.2 序列式容器： vector , deque , list 的战场

序列式容器维护元素的线性次序，即插入顺序。

  • std::vector ：动态数组。 底层是一段连续的线性空间。

    • 优势 ： 随机访问效率极高（O(1)） ，因为地址是连续的。 缓存友好 ，CPU预取机制能高效工作。在尾部进行插入删除效率高（摊销O(1)）。
    • 劣势 ：在头部或中部插入/删除元素成本高昂（O(n)），因为需要移动后续所有元素。内存增长时（ push_back 导致 capacity 不足）可能引发重新分配、拷贝和释放，虽然摊销后性能尚可，但可能造成迭代器、指针、引用失效。
    • 实战场景 ：存储需要频繁随机访问或遍历的数据集合，且插入删除主要在尾部。例如，渲染引擎中的顶点数据、物理引擎中的刚体列表、网络接收到的数据包缓冲区。
    • 关键技巧 ：如果提前知道或能估算元素数量，务必使用 reserve(n) 预分配空间，避免多次重分配的开销。

  • std::deque ：双端队列。 通常由一段段定长的连续空间（缓冲区）通过中央映射器（索引数组）链接而成。

    • 优势 ：在 头部和尾部 进行插入删除操作效率都很高（摊销O(1)）。支持随机访问，但效率略低于 vector 。
    • 劣势 ：中间插入删除效率低（O(n)）。随机访问需要计算，比 vector 慢。内存分布不连续，缓存友好性不如 vector 。
    • 实战场景 ：需要高效地在两端进行增删的场景，如任务队列、滑动窗口、历史记录（最新和最旧的操作都需要快速访问）。
    • 与vector的抉择 ：如果你95%的操作都在尾部，用 vector 。如果头尾操作都很频繁，用 deque 。

  • std::list ：双向链表。 每个元素（节点）独立分配，通过指针链接。

    • 优势 ：在 任何位置 插入删除元素（只要已获得该位置的迭代器）效率都是O(1)，且不会使其他元素的迭代器失效（除了被删除的那个）。
    • 劣势 ： 不支持随机访问 ，访问特定位置元素需要O(n)遍历。每个元素额外存储两个指针，内存开销大。内存碎片化，缓存非常不友好。
    • 实战场景 ：需要频繁在容器中间进行插入删除，且不需要随机访问。例如，实现LRU缓存淘汰算法时，需要将访问的节点移动到链表头部。
    • 重要提醒 ：在大多数情况下， list 的性能不如 vector 或 deque ，除非你的中间插入删除操作极其频繁且数据量很大。现代CPU缓存体系下，连续内存的遍历速度可能远超链表，即使链表理论复杂度更低。

2.3 关联式容器： map/set 与 unordered_map/unordered_set 的对决

关联式容器通过键（Key）来存储和检索元素。

  • std::map / std::set ：基于红黑树实现。

    • 优势 ：元素是 自动排序 的（默认按 < 比较）。提供了稳定的O(log n)的查找、插入和删除复杂度。支持进行范围查询（如 lower_bound , upper_bound ）。
    • 劣势 ：由于需要维护树结构，插入删除比哈希表慢。内存开销比哈希表大。
    • 实战场景 ：需要元素始终保持有序，或者需要范围查询。例如，存储游戏中的玩家分数排行榜（需要按分数排序并快速获取前N名），或者配置项（键需要按字母顺序列出）。

  • std::unordered_map / std::unordered_set ：基于哈希表实现。

    • 优势 ：提供了平均O(1)，最坏O(n)的查找、插入和删除效率，通常远快于树结构。 不关心元素顺序 。
    • 劣势 ：元素是无序的。哈希函数的质量和负载因子直接影响性能，最坏情况（大量哈希冲突）会退化为链表。自定义类型作为键时需要提供哈希函数和相等比较器。
    • 实战场景 ：需要极快的查找速度，且不要求顺序。这是目前最常用的关联容器。例如，游戏中的对象ID到对象指针的映射、缓存系统、词频统计。

关键抉择点 ：是否需要有序？要有序，选 map/set ；要极致查找速度且无序，选 unordered_map/unordered_set 。在C++11之后，除非有明确的有序需求，否则 unordered_map 通常是默认选择。

3. 核心细节解析与避坑指南

知道选什么容器只是第一步，用对、用好才是关键。下面这些细节，是区分“新手”和“老手”的标尺。

3.1 vector 的 size 、 capacity 与内存管理

这是 vector 最核心也最容易混淆的概念。

  • size() : 返回当前容器中实际拥有的元素数量。
  • capacity() : 返回当前容器在不重新分配内存的情况下，最多可以容纳的元素数量。
  • resize(n) : 改变 size() 。如果 n > size() ，则会在尾部添加 n-size() 个元素（值初始化或拷贝构造）；如果 n < size() ，则会销毁尾部的 size()-n 个元素。 capacity() 可能不变，也可能缩小（取决于实现）。
  • reserve(n) : 改变 capacity() 。它确保容器的容量至少为 n 。如果 n 大于当前 capacity() ，则会重新分配内存，并将旧元素移动或拷贝到新内存， capacity() 变为至少 n ，但 size() 不变。如果 n <= capacity() ，则什么也不做。

踩坑实录 ： 

std::vector<int> vec;
vec.reserve(100); // 只分配内存，size()仍为0
for (int i = 0; i < 100; ++i) {
    vec[i] = i; // 灾难！未定义行为，因为size()为0，下标访问越界。
}

正确做法是 push_back 或先 resize 。 

std::vector<MyClass> vec;
vec.resize(10); // 调用了10次MyClass的默认构造函数
// ... 一些操作后
vec.clear(); // size()变为0，但capacity()不变，内存未释放
vec.shrink_to_fit(); // C++11，请求释放未使用的内存（capacity可能缩小到size）

经验法则 ：在已知或可预估数据量上限时，优先使用 reserve ，避免多次扩容带来的性能损耗和迭代器失效问题。

3.2 迭代器失效：容器操作的隐形杀手

在修改容器时，指向容器元素的迭代器、指针或引用可能会变得无效。这是STL使用中最常见的Bug来源之一。

  • vector / deque ：所有可能引起内存重新分配的操作（如 insert , push_back 导致 capacity 不足），会使 所有 迭代器、指针、引用失效。在中间插入删除，会使 插入/删除点之后 的迭代器、指针、引用失效。
  • list / map / set / unordered_* ：插入操作 不会 使任何迭代器失效（除了指向被删除元素的）。删除操作 只会 使指向被删除元素的迭代器失效，其他迭代器仍然有效。

避坑技巧 ：

  1. 在循环中删除元素 ：这是经典陷阱。对于 vector / deque ，错误做法会导致崩溃或逻辑错误。 
    // 错误示范：删除所有偶数
std::vector<int> v = {1,2,3,4,5};
for (auto it = v.begin(); it != v.end(); ++it) {
    if (*it % 2 == 0) {
        v.erase(it); // erase后，it失效！后续++it行为未定义！
    }
}
    正确做法是利用 erase 的返回值 （返回被删除元素之后元素的有效迭代器）： 
    for (auto it = v.begin(); it != v.end(); ) {
    if (*it % 2 == 0) {
        it = v.erase(it); // it被更新为下一个有效位置
    } else {
        ++it;
    }
}
    对于 list 和关联容器，因为只有被删迭代器失效，所以可以这样，但用返回值的写法更通用安全： 
    // 对于list/map等，以下写法可行但不推荐，推荐上面通用写法
std::list<int> l = {1,2,3,4,5};
for (auto it = l.begin(); it != l.end(); ) {
    if (*it % 2 == 0) {
        it = l.erase(it); // 仍然建议使用返回值
    } else {
        ++it;
    }
}
  2. 先保存迭代器，后操作容器 ：如果需要在容器操作后继续使用某个位置的迭代器，务必在操作后重新获取，或者使用 insert / emplace 的返回值。

3.3 map 的 operator[] 与 insert/emplace 的微妙差异

  • map[key] ：如果 key 不存在，它会使用 key 和 value 类型的默认构造函数 插入一个键值对 ，然后返回其值的引用。如果 key 存在，则返回现有值的引用。 注意 ：即使你只是想做查找， operator[] 也会在键不存在时执行插入！这可能导致意外的副作用和性能开销。
  • map.insert({key, value}) 或 map.emplace(key, value) ：只有当 key 不存在时，才会插入键值对。如果 key 已存在，则插入失败，返回一个 pair<iterator, bool> ，其中 bool 为 false 。 emplace 可以直接在容器内构造对象，避免临时对象的拷贝，通常更高效。

实战选择 ：

  • “查找-如果不存在则插入” ：使用 insert 或 emplace ，并检查返回值。 
    std::map<std::string, int> wordCount;
auto [it, inserted] = wordCount.emplace("hello", 1); // C++17 结构化绑定
if (!inserted) {
    // "hello"已存在，it指向已存在的元素
    it->second++; // 增加计数
}
  • “更新或插入”（upsert） ：在C++17之前，需要先 find 再判断，或者直接用 operator[] 。C++17提供了 try_emplace 和 insert_or_assign ，语义更清晰。 
    // C++17 try_emplace: 键不存在时才构造value，避免不必要的默认构造
wordCount.try_emplace("world", 1); // 仅当"world"不存在时插入
// C++17 insert_or_assign: 总是插入或赋值
wordCount.insert_or_assign("world", 5); // 无论是否存在，值都变为5
  • 纯查找，绝不插入 ：使用 find 成员函数。 
    auto it = wordCount.find("hello");
if (it != wordCount.end()) {
    // 找到了，使用 it->second
}

4. 基础实战案例：一个简单的单词频率统计程序

让我们用一个综合案例，串联起 vector , map , unordered_map 的选择和使用技巧。

需求 ：读取一段文本，统计每个单词出现的频率，并按照频率从高到低输出前10个单词。

4.1 版本1：使用 std::vector 和 std::sort （基础版）

思路：将单词和频率组成 pair ，存入 vector ，然后排序。 

#include <iostream>
#include <vector>
#include <string>
#include <algorithm>
#include <sstream>
#include <cctype>

// 辅助函数：移除标点，转小写
std::string sanitizeWord(const std::string& word) {
    std::string result;
    for (char ch : word) {
        if (std::isalpha(ch)) {
            result.push_back(std::tolower(ch));
        }
    }
    return result;
}

int main() {
    std::string text = "Hello world! Hello C++. C++ is powerful. World is big.";
    std::istringstream iss(text);
    std::string rawWord;

    // 使用vector存储pair<单词，频率>
    std::vector<std::pair<std::string, int>> wordVec;

    while (iss >> rawWord) {
        std::string word = sanitizeWord(rawWord);
        if (word.empty()) continue;

        // 查找单词是否已在vector中
        auto it = std::find_if(wordVec.begin(), wordVec.end(),
                               [&word](const auto& p) { return p.first == word; });
        if (it != wordVec.end()) {
            it->second++; // 频率加1
        } else {
            wordVec.emplace_back(word, 1); // 插入新单词
        }
    }

    // 按频率降序排序
    std::sort(wordVec.begin(), wordVec.end(),
              [](const auto& a, const auto& b) { return a.second > b.second; });

    // 输出前10个
    int count = 0;
    for (const auto& [w, freq] : wordVec) {
        if (count++ >= 10) break;
        std::cout << w << ": " << freq << std::endl;
    }
    return 0;
}

分析 ：这个版本可行，但效率低。每次插入新单词，都需要在 vector 中线性查找( O(n) )，整体时间复杂度为 O(n^2) 。对于大量文本不可行。

4.2 版本2：使用 std::map （有序，自动聚合）

思路：利用 map 的键唯一性和自动排序（按字母顺序），可以高效地统计频率。 

#include <iostream>
#include <map>
#include <string>
#include <sstream>
#include <cctype>
#include <vector>
#include <algorithm>

std::string sanitizeWord(const std::string& word) { /* 同上 */ }

int main() {
    std::string text = "Hello world! Hello C++. C++ is powerful. World is big.";
    std::istringstream iss(text);
    std::string rawWord;

    std::map<std::string, int> wordMap; // 按键（单词）字母顺序排序

    while (iss >> rawWord) {
        std::string word = sanitizeWord(rawWord);
        if (word.empty()) continue;
        wordMap[word]++; // 利用operator[]的特性：查找并递增，不存在则插入0再递增
    }

    // 此时wordMap是按单词字母顺序排序的，我们需要按频率排序
    // 将map内容拷贝到vector中排序
    std::vector<std::pair<std::string, int>> wordVec(wordMap.begin(), wordMap.end());
    std::sort(wordVec.begin(), wordVec.end(),
              [](const auto& a, const auto& b) { return a.second > b.second; });

    int count = 0;
    for (const auto& [w, freq] : wordVec) {
        if (count++ >= 10) break;
        std::cout << w << ": " << freq << std::endl;
    }
    return 0;
}

分析 ：统计阶段效率大大提升，因为 map 的插入和查找是 O(log n) 。但最后需要一次 O(n log n) 的排序（将map转存到vector再排序）。另外， map 默认按键排序，对最终按值排序没有帮助，反而因为树结构的原因，遍历和拷贝开销比 vector 大。

4.3 版本3：使用 std::unordered_map （哈希表，最高效）

思路：统计阶段使用最快的 unordered_map ，最后再排序输出。 

#include <iostream>
#include <unordered_map> // 改为unordered_map
#include <string>
#include <sstream>
#include <cctype>
#include <vector>
#include <algorithm>

std::string sanitizeWord(const std::string& word) { /* 同上 */ }

int main() {
    std::string text = "Hello world! Hello C++. C++ is powerful. World is big.";
    std::istringstream iss(text);
    std::string rawWord;

    std::unordered_map<std::string, int> wordMap; // 哈希表，查找O(1)

    while (iss >> rawWord) {
        std::string word = sanitizeWord(rawWord);
        if (word.empty()) continue;
        wordMap[word]++; // 平均O(1)的操作
    }

    // 拷贝到vector排序（同版本2）
    std::vector<std::pair<std::string, int>> wordVec(wordMap.begin(), wordMap.end());
    std::sort(wordVec.begin(), wordVec.end(),
              [](const auto& a, const auto& b) { return a.second > b.second; });

    int count = 0;
    for (const auto& [w, freq] : wordVec) {
        if (count++ >= 10) break;
        std::cout << w << ": " << freq << std::endl;
    }
    return 0;
}

分析 ：这是 最佳实践 。统计阶段利用哈希表达到平均O(1)的效率。最终的排序是不可避免的，因为我们需要的是按值（频率）排序，而任何关联容器都是按键排序。将哈希表的结果转存到 vector 再排序，利用了 vector 连续内存排序快的优势。

性能对比小结 ：

操作 版本1 (vector+线性查找) 版本2 (map) 版本3 (unordered_map+vector sort)
插入/更新一个单词 O(n) O(log n) O(1) 平均
总体统计复杂度 O(n²) O(n log n) O(n) 平均
最终排序 直接在vector上排序 需拷贝到vector再排序 需拷贝到vector再排序
内存局部性 好 差 统计时差，排序时好

显然，版本3在数据量较大时优势巨大。这个案例清晰地展示了： 选择正确的容器，对程序性能有数量级的影响。

5. 进阶实战：利用容器特性解决特定问题

5.1 使用 std::list 实现LRU缓存

LRU（最近最少使用）缓存淘汰算法需要快速找到最久未使用的项并将其移除，同时在访问某项时能快速将其标记为最新使用。链表可以O(1)地移动节点到头部，哈希表可以O(1)地查找节点。 

#include <iostream>
#include <list>
#include <unordered_map>

template<typename K, typename V>
class LRUCache {
private:
    using ListIter = typename std::list<std::pair<K, V>>::iterator;
    size_t capacity_;
    std::list<std::pair<K, V>> cacheList_; // 存储实际的键值对，链表头部是最近使用的
    std::unordered_map<K, ListIter> cacheMap_; // 键到链表迭代器的映射

public:
    explicit LRUCache(size_t capacity) : capacity_(capacity) {}

    V get(const K& key) {
        auto it = cacheMap_.find(key);
        if (it == cacheMap_.end()) {
            // 可返回默认值或抛出异常，这里简单返回V()
            return V();
        }
        // 找到，将该节点移动到链表头部（标记为最新使用）
        cacheList_.splice(cacheList_.begin(), cacheList_, it->second);
        // it->second 迭代器仍然有效，但指向的位置变了
        // map中的迭代器需要更新吗？不需要，splice操作不使迭代器失效，且迭代器指向的节点没变
        return it->second->second;
    }

    void put(const K& key, const V& value) {
        auto it = cacheMap_.find(key);
        if (it != cacheMap_.end()) {
            // 键已存在，更新值，并移动到头部
            it->second->second = value;
            cacheList_.splice(cacheList_.begin(), cacheList_, it->second);
            return;
        }

        // 键不存在，需要插入
        if (cacheMap_.size() >= capacity_) {
            // 缓存已满，淘汰链表尾部的节点（最久未使用）
            auto last = cacheList_.end();
            --last; // 指向最后一个元素
            cacheMap_.erase(last->first); // 从map中删除
            cacheList_.pop_back();        // 从list中删除
        }

        // 插入新节点到链表头部
        cacheList_.emplace_front(key, value);
        cacheMap_[key] = cacheList_.begin(); // 在map中记录迭代器
    }
};

设计要点 ：

  1. std::list ：用于维护访问顺序。链表头部是最近使用的，尾部是最久未使用的。 splice 操作可以在O(1)时间内将节点移动到头部，且 不会使其他迭代器失效 ，这是选择 list 而非 vector 或 deque 的关键原因。
  2. std::unordered_map ：用于实现O(1)的键查找，直接映射到链表中的节点迭代器。
  3. 迭代器有效性 ： list 的插入删除不会使其他迭代器失效，这保证了 map 中存储的迭代器在 list 结构变化后仍然有效（除非对应的节点被删除）。这是该设计能成立的核心保障。

5.2 使用 std::priority_queue 管理任务优先级

priority_queue （优先队列）虽然是一个容器适配器（底层默认用 vector ），但它完美体现了“选择合适数据结构”的思想。它总是保证优先级最高的元素在队首。 

#include <iostream>
#include <queue>
#include <vector>
#include <string>

struct Task {
    std::string description;
    int priority; // 数字越小，优先级越高（最小堆）

    // 重载<运算符，用于priority_queue的比较（默认是最大堆，我们需要最小堆）
    bool operator<(const Task& other) const {
        // 注意：priority_queue默认是最大堆，所以这里用 > 来实现“值小的优先级高”
        return priority > other.priority;
    }
};

int main() {
    // 使用最小堆：priority_queue<T, Container, Compare>
    // std::greater<Task> 需要Task有>运算符，我们定义了<，也可以直接用std::greater<>
    // 这里使用默认的less，但我们在Task的<中反转了逻辑，实现了最小堆。
    std::priority_queue<Task> taskQueue;

    taskQueue.push({"Fix critical bug", 1});
    taskQueue.push({"Write documentation", 5});
    taskQueue.push({"Refactor module A", 3});
    taskQueue.push({"Handle user request", 2});

    while (!taskQueue.empty()) {
        Task topTask = taskQueue.top();
        std::cout << "Processing: " << topTask.description
                  << " [Priority: " << topTask.priority << "]" << std::endl;
        taskQueue.pop();
    }
    // 输出顺序将是：Fix bug (1) -> Handle request (2) -> Refactor (3) -> Write docs (5)
    return 0;
}

底层容器选择 ： priority_queue 默认使用 vector 作为底层容器。因为堆（heap）操作（ push_heap , pop_heap ）需要随机访问迭代器， vector 提供了最好的性能。虽然 deque 也支持随机访问，但 vector 的连续内存对堆算法更友好。

6. 性能陷阱与最佳实践总结

  1. 避免在 vector 中间频繁插入删除 ：这是最昂贵的操作。如果无法避免，考虑使用 list ，但务必先做性能测试，因为 list 的缓存不友好可能抵消其理论优势。
  2. unordered_map 的哈希冲突 ：如果自定义类型作为键，必须提供良好的哈希函数。糟糕的哈希函数会导致大量冲突，性能退化为O(n)。可以使用标准库为基本类型和字符串提供的特化版本，或使用 std::hash 的组合。
  3. map 的 operator[] 的副作用 ：牢记它可能插入元素。纯查找请用 find 。
  4. 迭代器失效规则必须牢记 ：在修改容器时，时刻问自己：我持有的迭代器、指针、引用还安全吗？特别是在循环中。
  5. 善用 emplace 系列函数 ： emplace_back , emplace , try_emplace , emplace_hint 等可以直接在容器内构造对象，避免创建临时对象再拷贝或移动，能提升性能，尤其是对于非平凡类型。
  6. reserve 是 vector 和 unordered_map 的好朋友 ：如果能预估大小，提前 reserve 可以避免多次重分配。
  7. 理解容器操作的复杂度 ： list 的 size() 在C++11前可能是O(n)，现在标准要求是O(1)，但具体实现可能不同。 unordered_map 的遍历顺序是未指定的，并且可能因重哈希而改变。
  8. C++17及之后的现代特性 ： try_emplace 和 insert_or_assign 让 map 的操作更安全清晰。 extract 成员函数允许在关联容器中移动节点，避免拷贝，在转移容器所有权时非常高效。

STL容器是C++程序员的基石工具。从“知道有哪些容器”到“在正确的地方使用正确的容器”，再到“深入理解其行为并规避陷阱”，是一个不断积累经验的过程。最好的学习方法就是带着问题去使用，在调试中理解，在性能分析中优化。希望这些实战中的细节和思考，能让你在使用STL容器时更加得心应手。

Logo
亚马逊云科技技术品牌专区

更多推荐

open-code-review Codex 插件教程：对话式调用评审技能指南

本文是一份面向新手的 **open-code-review Codex 插件教程**，教你在 Codex 中通过对话式方式调用 open-code-review 的 AI 代码评审技能。open-code-review 是阿里巴巴开源的 AI 代码评审工具，采用"确定性流水线 + LLM Agent"混合架构，内置多语言评审规则（NPE、线程安全、XSS、SQL 注入等），可在 Codex 里用一

avatar 亚马逊云科技技术品牌专区

OBS Studio 完整指南：免费开源录屏与直播软件从零上手

想做一场像模像样的直播，或者把屏幕内容录成教程视频，但一想到商用软件的订阅费就有些犹豫？其实你不需要花一分钱。OBS Studio 是一款免费开源的直播与录屏软件，支持 Windows、macOS 和 Linux，采集、混音、编码、推流、录制，一条流水线全包了。## 先搞清楚 OBS Studio 是什么OBS Studio 是一个"场景化"的采集合成工具：你把摄像头、窗口、浏览器、图片、

avatar 亚马逊云科技技术品牌专区

如何用MediaCrawler爬取小红书抖音数据？7大平台爬虫从安装到实战完整指南

MediaCrawler 是一个支持小红书、抖音、快手、B站、微博、百度贴吧、知乎的开源自媒体数据采集工具。它能按关键词、按帖子、按创作者主页三种方式抓取笔记/视频内容、评论甚至二级评论，并把结果存成 JSON、CSV、Excel 或数据库。适合做市场调研、竞品监控、内容选题的运营人员，以及想要现成爬虫框架而不想从零写 JS 逆向的开发者。## 从一次"手动抄数据"说起想象这个场景：你负责

avatar 亚马逊云科技技术品牌专区