C++STL教程：容器适配器与实用工具

发布时间：2026-08-30 11:00:46

🕒 阅读时间：18 分钟📝 字数：2965👀 阅读量：Loading...

本文是 C++ 系列教程的第 15 篇。上一篇讲解了函数对象与 Lambda，本篇讲解容器适配器与实用工具：stack/queue/priority_queue（含自定义比较）、pair/tuple（结构化绑定）、bitset、chrono 时间库、random 随机数库。

一、容器适配器

1.1 什么是容器适配器

容器适配器是基于其他容器包装出的受限接口容器，只暴露特定操作：

适配器	底层容器（默认）	特性
stack	deque	后进先出 LIFO
queue	deque	先进先出 FIFO
priority_queue	vector	按优先级出队

二、stack 栈

2.1 stack 基本操作

1
#include <iostream>
2
#include <stack>
3
using namespace std;
4

5
int main() {
6
    stack<int> s;
7

8
    // 入栈
9
    s.push(10);
10
    s.push(20);
11
    s.push(30);
12

13
    cout << "栈大小: " << s.size() << endl;   // 3
14
    cout << "栈顶: " << s.top() << endl;      // 30
15

16
    // 出栈
17
    s.pop();
18
    cout << "出栈后栈顶: " << s.top() << endl;  // 20
19

20
    // 遍历（弹出方式）
21
    while (!s.empty()) {
22
        cout << s.top() << " ";
23
        s.pop();
24
    }
25
    cout << endl;   // 20 10
26
    return 0;
27
}

2.2 stack 实战：括号匹配

1
#include <iostream>
2
#include <stack>
3
#include <string>
4
using namespace std;
5

6
bool isBalanced(const string &expr) {
7
    stack<char> s;
8
    for (char c : expr) {
9
        if (c == '(' || c == '[' || c == '{') {
10
            s.push(c);
11
        } else if (c == ')' || c == ']' || c == '}') {
12
            if (s.empty()) return false;
13
            char top = s.top();
14
            s.pop();
15
            // 检查是否匹配
16
            if ((c == ')' && top != '(') ||
17
                (c == ']' && top != '[') ||
18
                (c == '}' && top != '{')) {
19
                return false;
20
            }
21
        }
22
    }
23
    return s.empty();
24
}
25

26
int main() {
27
    cout << "(()): " << isBalanced("(())") << endl;       // 1
28
    cout << "([{}]): " << isBalanced("([{}])" << endl;   // 1
29
    cout << "(()]: " << isBalanced("(()]") << endl;       // 0
30
    cout << "([)]: " << isBalanced("([])") << endl;       // 0
31
    cout << "empty: " << isBalanced("") << endl;           // 1
32
    return 0;
33
}

三、queue 队列

3.1 queue 基本操作

1
#include <iostream>
2
#include <queue>
3
using namespace std;
4

5
int main() {
6
    queue<int> q;
7

8
    // 入队
9
    q.push(10);
10

11
q.push(20);
12
    q.push(30);
13

14
    cout << "队首: " << q.front() << endl;   // 10
15
    cout << "队尾: " << q.back() << endl;    // 30
16

17
    // 出队
18
    q.pop();
19
    cout << "出队后队首: " << q.front() << endl;  // 20
20

21
    // 遍历（弹出方式）
22
    while (!q.empty()) {
23
        cout << q.front() << " ";
24
        q.pop();
25
    }
26
    cout << endl;   // 20 30
27
    return 0;
28
}

3.2 queue 实战：任务队列

1
#include <iostream>
2
#include <queue>
3
#include <string>
4
using namespace std;
5

6
struct Task {
7
    string name;
8
    int priority;
9

10
    Task(string n, int p) : name(n), priority(p) {}
11
};
12

13
int main() {
14
    queue<Task> tasks;
15

16
    tasks.push(Task("备份数据", 1));
17
    tasks.push(Task("发送邮件", 2));
18
    tasks.push(Task("生成报表", 3));
19

20
    // 依次处理任务
21
    while (!tasks.empty()) {
22
        Task t = tasks.front();
23
        tasks.pop();
24
        cout << "处理: " << t.name << "（优先级 " << t.priority << "）" << endl;
25
    }
26
    return 0;
27
}

四、priority_queue 优先队列

4.1 基本用法

1
#include <iostream>
2
#include <queue>
3
using namespace std;
4

5
int main() {
6
    // 默认：大顶堆（最大元素在队首）
7
    priority_queue<int> pq;
8
    pq.push(30);
9
    pq.push(10);
10
    pq.push(50);
11
    pq.push(20);
12

13
    cout << "最大值: " << pq.top() << endl;  // 50
14
    pq.pop();
15
    cout << "弹出后: " << pq.top() << endl;  // 30
16

17
    // 小顶堆（最小元素在队首）
18
    priority_queue<int, vector<int>, greater<int>> minPQ;
19
    minPQ.push(30);
20
    minPQ.push(10);
21
    minPQ.push(50);
22
    cout << "最小值: " << minPQ.top() << endl;  // 10
23
    return 0;
24
}

4.2 自定义类型的优先队列

1
#include <iostream>
2
#include <queue>
3
#include <string>
4
using namespace std;
5

6
struct Patient {
7
    string name;
8
    int severity;    // 病情严重程度
9

10
    Patient(string n, int s) : name(n), severity(s) {}
11
};
12

13
// 自定义比较：severity 大的优先
14
struct ComparePatient {
15
    bool operator()(const Patient &a, const Patient &b) const {
16
        return a.severity < b.severity;   // 与 sort 相反
17
    }
18
};
19

20
int main() {
21
    priority_queue<Patient, vector<Patient>, ComparePatient> er;
22

23
    er.push(Patient("张三", 3));
24
    er.push(Patient("李四", 5));
25
    er.push(Patient("王五", 2));
26
    er.push(Patient("赵六", 4));
27

28
    // 按病情紧急程度出队
29
    while (!er.empty()) {
30

31
    Patient p = er.top();
32
        er.pop();
33
        cout << "接诊: " << p.name << "（危重等级 " << p.severity << "）" << endl;
34
    }
35
    return 0;
36
}

五、pair 与 tuple

5.1 pair 键值对

1
#include <iostream>
2
#include <utility>
3
#include <string>
4
using namespace std;
5

6
int main() {
7
    // pair 存储两个值
8
    pair<string, int> p1("张三", 88);
9
    pair<string, int> p2 = {"李四", 92};
10
    auto p3 = make_pair("王五", 76);   // 类型推导
11

12
    cout << p1.first << ": " << p1.second << endl;
13
    cout << p2.first << ": " << p2.second << endl;
14

15
    // 修改
16
    p3.second = 80;
17
    cout << p3.first << ": " << p3.second << endl;
18

19
    // 比较（先比 first 再比 second）
20
    cout << (p1 < p2) << endl;   // "张三" < "李四"? 0
21

22
    // 结构化绑定（C++17）
23
    auto [name, score] = p1;
24
    cout << "绑定: " << name << " " << score << endl;
25
    return 0;
26
}

5.2 tuple 多元组

1
#include <iostream>
2
#include <tuple>
3
#include <string>
4
using namespace std;
5

6
int main() {
7
    // tuple 可存储任意多个不同类型值
8
    tuple<int, string, double> t1(1, "Alice", 88.5);
9
    auto t2 = make_tuple(2, "Bob", 95.0);
10

11
    // 访问
12
    cout << get<0>(t1) << " " << get<1>(t1) << " " << get<2>(t1) << endl;
13

14
    // 修改
15
    get<2>(t1) = 90.0;
16
    cout << "修改后: " << get<2>(t1) << endl;
17

18
    // 结构化绑定（C++17）
19
    auto [id, name, score] = t2;
20
    cout << id << " " << name << " " << score << endl;
21

22
    // tie：同时解包
23
    int i;
24
    string s;
25
    double d;
26
    tie(i, s, d) = t1;
27
    cout << i << " " << s << " " << d << endl;
28
    return 0;
29
}

六、bitset 位集

6.1 bitset 基本操作

1
#include <iostream>
2
#include <bitset>
3
using namespace std;
4

5
int main() {
6
    // 8 位位集
7
    bitset<8> b1;             // 00000000
8
    bitset<8> b2(42);         // 00101010（十进制转二进制）
9
    bitset<8> b3("10101111"); // 从字符串构造
10

11
    cout << "b1: " << b1 << endl;
12
    cout << "b2: " << b2 << endl;
13
    cout << "b3: " << b3 << endl;
14

15
    // 位操作
16
    b3.set(0);       // 设置第 0 位
17
    b3.reset(1);     // 清除第 1 位
18
    b3.flip(2);      // 翻转第 2 位
19
    cout << "操作后: " << c3 << endl;
20

21
    // 查询
22
    cout << "b3 中 1 的个数: " << b3.count() << endl;
23
    cout << "b3 大小: " << b3.size() << endl;
24
    cout << "b3 是否有 1: " << b3.any() <<
25
 endl;
26

27
    // 位运算
28
    bitset<8> result = b2 & b3;
29
    cout << "b2 & b3: " << result << endl;
30
    return 0;
31
}

6.2 bitset 实战：素数筛选

1
#include <iostream>
2
#include <bitset>
3
using namespace std;
4

5
// 用 bitset 实现埃拉托斯特尼筛法
6
void sieve(int n) {
7
    bitset<1000> isComposite;
8
    for (int i = 2; i * i <= n; i++) {
9
        if (!isComposite[i]) {
10
            for (int j = i * i; j <= n; j += i) {
11
                isComposite[j] = true;
12
            }
13
        }
14
    }
15

16
    cout << "素数: ";
17
    for (int i = 2; i <= n; i++) {
18
        if (!isComposite[i]) cout << i << " ";
19
    }
20
    cout << endl;
21
}
22

23
int main() {
24
    sieve(50);
25
    return 0;
26
}

七、chrono 时间库

7.1 时间点与时长

1
#include <iostream>
2
#include <chrono>
3
#include <thread>
4
using namespace std;
5
using namespace chrono;
6

7
int main() {
8
    // 当前时间点
9
    auto now = system_clock::now();
10
    cout << "当前时间戳: " << duration_cast<milliseconds>(now.time_since_epoch()).count() << " ms" << endl;
11

12
    // 时长类型
13
    seconds s(10);
14
    milliseconds ms(1500);
15
    minutes m(2);
16

17
    // 时长运算
18
    auto total = s + duration_cast<seconds>(ms) + m;
19
    cout << "总时长: " << total.count() << " 秒" << endl;  // 131
20

21
    // 时长换算
22
    auto ms2 = duration_cast<milliseconds>(total);
23
    cout << "等于: " << ms2.count() << " 毫秒" << endl;    // 131000
24
    return 0;
25
}

7.2 程序计时

1
#include <iostream>
2
#include <chrono>
3
#include <vector>
4
#include <algorithm>
5
using namespace std;
6
using namespace chrono;
7

8
int main() {
9
    vector<int> data(100000);
10
    for (int i = 0; i < 100000; i++) data[i] = rand() % 100000;
11

12
    // 开始计时
13
    auto start = high_resolution_clock::now();
14

15
    sort(data.begin(), data.end());
16

17
    // 结束计时
18
    auto end = high_resolution_clock::now();
19
    auto duration = duration_cast<milliseconds>(end - start);
20

21
    cout << "排序耗时: " << duration.count() << " 毫秒" << endl;
22
    return 0;
23
}

八、random 随机数库

8.1 现代随机数（优于 rand）

1
#include <iostream>
2
#include <random>
3
using namespace std;
4

5
int main() {
6
    // 随机数引擎 + 种子
7
    random_device rd;              // 真随机种子
8
    mt19937 gen(rd());             // 梅森旋转引擎
9

10
    // 均匀分布 [1, 100]
11
    uniform_int_distribution<int> intDist(1, 100);
12

13
  for (int i = 0; i < 5; i++) {
14
        cout << intDist(gen) << " ";
15
    }
16
    cout << endl;
17

18
    // 均匀浮点 [0.0, 1.0)
19
    uniform_real_distribution<double> realDist(0.0, 1.0);
20
    for (int i = 0; i < 5; i++) {
21
        cout << realDist(gen) << " ";
22
    }
23
    cout << endl;
24

25
    // 正态分布（均值为 0，标准差 1）
26
    normal_distribution<double> normalDist(0.0, 1.0);
27
    for (int i = 0; i < 5; i++) {
28
        cout << normalDist(gen) << " ";
29
    }
30
    cout << endl;
31
    return 0;
32
}

8.2 rand vs 现代随机数

维度	rand()	现代随机数库
头文件	cstdlib	random
分布	只有均匀整数	多种分布
质量	较差	高质量（MT19937）
种子	需手动 srand	random_device
推荐	不推荐	推荐

九、实战：任务调度系统

综合本篇知识，实现优先任务调度：

1
#include <iostream>
2
#include <queue>
3
#include <chrono>
4
#include <string>
5
using namespace std;
6
using namespace chrono;
7

8
struct Job {
9
    string id;
10
    int priority;       // 优先级（越大越优先）
11
    double duration;    // 预计耗时（秒）
12

13
    Job(string i, int p, double d) : id(i), priority(p), duration(d) {}
14
};
15

16
// 大顶堆：优先级高的先执行
17
struct CompareJob {
18
    bool operator()(const Job &a, const Job &b) const {
19
        return a.priority < b.priority;
20
    }
21
};
22

23
int main() {
24
    priority_queue<Job, vector<Job>, CompareJob> scheduler;
25

26
    scheduler.push(Job("J1", 3, 1.5));
27
    scheduler.push(Job("J2", 5, 0.8));
28
    scheduler.push(Job("J3", 1, 2.0));
29
    scheduler.push(Job("J4", 4, 1.2));
30

31
    cout << "===== 任务调度（按优先级） =====" << endl;
32
    auto start = steady_clock::now();
33
    double totalTime = 0;
34

35
    while (!scheduler.empty()) {
36
        Job job = scheduler.top();
37
        scheduler.pop();
38
        cout << "执行 " << job.id << "（优先级 " << job.priority
39
             << "，预计 " << job.duration << " 秒）" << endl;
40
        totalTime += job.duration;
41
    }
42

43
    auto end = steady_clock::now();
44
    auto elapsed = duration_cast<milliseconds>(end - start);
45
    cout << "总任务数: 4，预计总耗时: " << totalTime << " 秒" << endl;
46
    return 0;
47
}

总结

本篇讲解了容器适配器（stack 后进先出、queue 先进先出、priority_queue 按优先级）、pair/tuple 多元组与结构化绑定、bitset 位操作与素数筛选、chrono 时间库的计时、random 现代随机数库，并用任务调度系统串联实战。重点掌握：priority_queue 的自定义比较（注意与 sort 相反）、结构化绑定的使用、chrono 计时模式、mt19937 + 分布的搭配。

STL 阶段（11-15 篇）完成！下一篇进入模板与泛型编程：函数模板与类模板入门，敬请期待！