020 《Boost Multi-index 权威指南：从入门到精通 (Boost Multi-index: The Definitive Guide from Beginner to Expert)》
🌟🌟🌟本文案由Gemini 2.0 Flash Thinking Experimental 01-21创作，用来辅助学习知识。🌟🌟🌟
书籍大纲
▮▮▮▮ 1. chapter 1： 初识 Boost Multi-index (Introduction to Boost Multi-index)
▮▮▮▮▮▮▮ 1.1 为什么选择 Multi-index (Why Choose Multi-index)
▮▮▮▮▮▮▮▮▮▮▮ 1.1.1 Multi-index 的优势 (Advantages of Multi-index)
▮▮▮▮▮▮▮▮▮▮▮ 1.1.2 Multi-index 的应用场景 (Application Scenarios of Multi-index)
▮▮▮▮▮▮▮ 1.2 Multi-index 核心概念 (Core Concepts of Multi-index)
▮▮▮▮▮▮▮▮▮▮▮ 1.2.1 容器 (Container)
▮▮▮▮▮▮▮▮▮▮▮ 1.2.2 索引 (Index)
▮▮▮▮▮▮▮▮▮▮▮ 1.2.3 键提取器 (Key Extractor)
▮▮▮▮▮▮▮▮▮▮▮ 1.2.4 排序 (Ordering)
▮▮▮▮▮▮▮ 1.3 第一个 Multi-index 容器 (Your First Multi-index Container)
▮▮▮▮▮▮▮▮▮▮▮ 1.3.1 简单的示例代码 (Simple Example Code)
▮▮▮▮▮▮▮▮▮▮▮ 1.3.2 编译和运行 (Compilation and Execution)
▮▮▮▮ 2. chapter 2： 索引类型详解 (Detailed Explanation of Index Types)
▮▮▮▮▮▮▮ 2.1 有序索引 (Ordered Indices)
▮▮▮▮▮▮▮▮▮▮▮ 2.1.1 ordered_unique
▮▮▮▮▮▮▮▮▮▮▮ 2.1.2 ordered_non_unique
▮▮▮▮▮▮▮ 2.2 哈希索引 (Hashed Indices)
▮▮▮▮▮▮▮▮▮▮▮ 2.2.1 hashed_unique
▮▮▮▮▮▮▮▮▮▮▮ 2.2.2 hashed_non_unique
▮▮▮▮▮▮▮ 2.3 序列索引 (Sequenced Indices) - sequenced
▮▮▮▮▮▮▮ 2.4 随机访问索引 (Random Access Indices) - random_access
▮▮▮▮▮▮▮ 2.5 选择合适的索引类型 (Choosing the Right Index Type)
▮▮▮▮ 3. chapter 3： 键提取器 (Key Extractors)
▮▮▮▮▮▮▮ 3.1 默认键提取器 (Default Key Extractor)
▮▮▮▮▮▮▮ 3.2 成员指针键提取器 (Member Pointer Key Extractor) - member
▮▮▮▮▮▮▮ 3.3 全局函数键提取器 (Global Function Key Extractor) - global_fun
▮▮▮▮▮▮▮ 3.4 仿函数键提取器 (Functor Key Extractor) - const_mem_fun, mem_fun
▮▮▮▮▮▮▮ 3.5 lambda 表达式键提取器 (Lambda Expression Key Extractor)
▮▮▮▮▮▮▮ 3.6 复合键 (Composite Keys) - composite_key
▮▮▮▮ 4. chapter 4： 常用操作 (Common Operations)
▮▮▮▮▮▮▮ 4.1 插入元素 (Inserting Elements) - insert, emplace
▮▮▮▮▮▮▮ 4.2 查找元素 (Finding Elements) - find, count, lower_bound, upper_bound, equal_range
▮▮▮▮▮▮▮ 4.3 范围查询 (Range Queries)
▮▮▮▮▮▮▮ 4.4 修改元素 (Modifying Elements) - modify, replace
▮▮▮▮▮▮▮ 4.5 删除元素 (Erasing Elements) - erase, clear
▮▮▮▮▮▮▮ 4.6 迭代器 (Iterators) - 不同索引的迭代器
▮▮▮▮ 5. chapter 5： 高级特性 (Advanced Features)
▮▮▮▮▮▮▮ 5.1 索引集操作 (Index Set Operations)
▮▮▮▮▮▮▮ 5.2 对象持久化 (Object Persistence) 与序列化 (Serialization)
▮▮▮▮▮▮▮ 5.3 自定义索引类型 (Custom Index Types) 简介
▮▮▮▮▮▮▮ 5.4 性能考量与优化 (Performance Considerations and Optimization)
▮▮▮▮▮▮▮▮▮▮▮ 5.4.1 索引选择对性能的影响 (Impact of Index Choice on Performance)
▮▮▮▮▮▮▮▮▮▮▮ 5.4.2 内存占用 (Memory Footprint)
▮▮▮▮ 6. chapter 6： 实战案例 (Practical Case Studies)
▮▮▮▮▮▮▮ 6.1 案例一：学生信息管理系统 (Case Study 1: Student Information Management System)
▮▮▮▮▮▮▮▮▮▮▮ 6.1.1 需求分析 (Requirement Analysis)
▮▮▮▮▮▮▮▮▮▮▮ 6.1.2 设计与实现 (Design and Implementation)
▮▮▮▮▮▮▮▮▮▮▮ 6.1.3 代码详解 (Code Details)
▮▮▮▮▮▮▮ 6.2 案例二：游戏角色管理 (Case Study 2: Game Character Management)
▮▮▮▮▮▮▮▮▮▮▮ 6.2.1 需求分析 (Requirement Analysis)
▮▮▮▮▮▮▮▮▮▮▮ 6.2.2 设计与实现 (Design and Implementation)
▮▮▮▮▮▮▮▮▮▮▮ 6.2.3 代码详解 (Code Details)
▮▮▮▮▮▮▮ 6.3 案例三：网络连接管理器 (Case Study 3: Network Connection Manager)
▮▮▮▮▮▮▮▮▮▮▮ 6.3.1 需求分析 (Requirement Analysis)
▮▮▮▮▮▮▮▮▮▮▮ 6.3.2 设计与实现 (Design and Implementation)
▮▮▮▮▮▮▮▮▮▮▮ 6.3.3 代码详解 (Code Details)
▮▮▮▮ 7. chapter 7： API 参考 (API Reference)
▮▮▮▮▮▮▮ 7.1 multi_index_container 类
▮▮▮▮▮▮▮ 7.2 索引类型 (Index Types) 类
▮▮▮▮▮▮▮ 7.3 键提取器 (Key Extractors) 相关类和函数
▮▮▮▮▮▮▮ 7.4 迭代器 (Iterators) 相关类型
▮▮▮▮▮▮▮ 7.5 算法 (Algorithms) 支持
▮▮▮▮ 8. chapter 8： 最佳实践与常见问题 (Best Practices and Common Issues)
▮▮▮▮▮▮▮ 8.1 最佳实践 (Best Practices)
▮▮▮▮▮▮▮▮▮▮▮ 8.1.1 清晰地定义索引需求 (Clearly Define Index Requirements)
▮▮▮▮▮▮▮▮▮▮▮ 8.1.2 选择合适的索引类型 (Choose Appropriate Index Types)
▮▮▮▮▮▮▮▮▮▮▮ 8.1.3 高效的键提取器 (Efficient Key Extractors)
▮▮▮▮▮▮▮ 8.2 常见问题与解答 (Common Issues and Solutions)
▮▮▮▮▮▮▮▮▮▮▮ 8.2.1 编译错误 (Compilation Errors)
▮▮▮▮▮▮▮▮▮▮▮ 8.2.2 运行时错误 (Runtime Errors)
▮▮▮▮▮▮▮▮▮▮▮ 8.2.3 性能问题 (Performance Issues)
▮▮▮▮ 9. chapter 9： Boost.MultiIndex 的未来展望 (Future Trends of Boost Multi-index)
▮▮▮▮▮▮▮ 9.1 C++ 标准化与 Multi-index (C++ Standardization and Multi-index)
▮▮▮▮▮▮▮ 9.2 Multi-index 的发展趋势 (Development Trends of Multi-index)
1. chapter 1： 初识 Boost Multi-index (Introduction to Boost Multi-index)
1.1 为什么选择 Multi-index (Why Choose Multi-index)
1.1.1 Multi-index 的优势 (Advantages of Multi-index)
在软件开发中，我们经常需要根据不同的标准来组织和访问数据。例如，一个学生信息管理系统可能需要根据学生的学号、姓名或班级来查找学生信息。传统的方法通常是使用多个容器，每个容器按照不同的键排序，或者在每次需要不同排序时重新排序数据。但这两种方法都有其局限性：
① 使用多个容器会导致数据冗余和维护困难。当数据更新时，必须同步更新所有容器，容易出错且效率低下。
② 频繁地重新排序数据会消耗大量的计算资源，尤其是在数据量较大时，性能会显著下降。
Boost Multi-index 容器为解决这些问题提供了一个优雅而高效的方案。它允许我们在一个容器中创建多个索引（indices），每个索引都使用不同的键和排序方式。这意味着我们可以通过不同的接口，以不同的方式访问和操作同一份数据，而无需数据冗余或频繁的重新排序。
使用 Boost Multi-index 的主要优势包括：
① 数据一致性 (Data Consistency)：所有索引都指向同一份数据，避免了数据冗余和数据不一致的问题。在一个索引中修改数据，其他索引的视图也会同步更新。
② 高效的多 критерий 查询 (Efficient Multi-criteria Queries)：可以根据不同的索引快速查找和访问数据，无需每次都进行全表扫描或重新排序。
③ 灵活性 (Flexibility)：可以根据需求选择不同的索引类型和键提取方式，灵活地适应各种数据组织和访问需求。
④ 代码简洁性 (Code Conciseness)：相比于手动维护多个容器或实现复杂的排序逻辑，使用 Multi-index 可以大大简化代码，提高代码的可读性和可维护性。
⑤ 性能优化 (Performance Optimization)：Boost Multi-index 库经过高度优化，提供了高效的插入、删除、查找等操作，性能接近于甚至优于手写的定制化数据结构。
总而言之，Boost Multi-index 提供了一种强大而灵活的工具，用于管理需要通过多个键访问的数据集合，它在提高效率、简化代码和保证数据一致性方面具有显著的优势。
1.1.2 Multi-index 的应用场景 (Application Scenarios of Multi-index)
Boost Multi-index 容器由于其独特的优势，在各种应用场景中都能发挥重要作用。以下是一些典型的应用场景：
① 数据库索引 (Database Indexing)：模拟数据库索引功能，在一个数据集合上建立多个索引，加速不同条件下的数据检索。例如，在一个存储产品信息的容器中，可以分别按照产品ID、产品名称和价格建立索引，方便根据不同条件快速查找产品。
② 缓存管理 (Cache Management)：在缓存系统中，经常需要根据不同的策略（例如，最近最少使用 LRU、最不经常使用 LFU）来淘汰缓存项。Multi-index 可以用于构建复杂的缓存数据结构，通过不同的索引实现不同的淘汰策略。
③ 游戏开发 (Game Development)：在游戏开发中，需要高效地管理游戏对象，并根据不同的属性（例如，位置、ID、类型）快速查找和访问游戏对象。Multi-index 可以用于管理游戏世界中的各种实体，提高游戏性能。例如，可以根据游戏对象的位置建立空间索引，快速查找附近的敌人或道具。
④ 网络编程 (Network Programming)：在网络编程中，需要管理大量的网络连接，并根据不同的键（例如，连接ID、IP地址、端口号）来查找和管理连接。Multi-index 可以用于构建高效的连接管理器，方便地根据不同条件查找和操作连接。例如，可以根据 IP 地址和端口号建立索引，快速查找特定的连接。
⑤ 事件调度系统 (Event Scheduling System)：在事件调度系统中，需要根据事件的发生时间、优先级等属性来管理和调度事件。Multi-index 可以用于构建高效的事件队列，根据不同的条件快速查找和调度事件。例如，可以根据事件的发生时间建立索引，快速找到下一个需要执行的事件。
⑥ 图形图像处理 (Image Processing)：在图像处理中，可能需要根据像素的颜色、位置等属性来访问和处理像素。Multi-index 可以用于组织像素数据，方便根据不同属性进行图像分析和处理。
⑦ 金融数据分析 (Financial Data Analysis)：在金融数据分析中，需要处理大量的金融数据，并根据不同的维度（例如，时间、股票代码、交易价格）进行分析和查询。Multi-index 可以用于高效地组织和查询金融数据。
总而言之，任何需要在同一份数据上进行多 критерий 查找、排序或访问的应用场景，都可以考虑使用 Boost Multi-index。它能够有效地提高数据管理的效率和灵活性，简化代码并提升性能。
1.2 Multi-index 核心概念 (Core Concepts of Multi-index)
要深入理解和使用 Boost Multi-index，首先需要掌握其核心概念。Multi-index 的核心在于在一个容器中维护多个索引，从而实现多角度的数据访问。以下是 Multi-index 的几个关键概念：
1.2.1 容器 (Container)
multi_index_container 是 Boost Multi-index 提供的核心容器类。它类似于 std::set 或 std::vector，但功能更加强大。multi_index_container 本身并不直接存储数据，而是管理着多个索引，每个索引都指向容器中存储的元素。
可以把 multi_index_container 想象成一个数据库表，而每个索引就像是表上的一个索引。数据实际存储在容器内部，而索引则提供了不同的访问路径。
multi_index_container 的定义通常包含两个主要部分：
① 元素类型 (Element Type)：指定容器中存储的数据类型。这可以是任何 C++ 类型，包括基本类型、自定义结构体或类。
② 索引描述符列表 (Index Descriptor List)：定义容器要维护的索引类型和属性。这是一个模板参数列表，用于指定要创建的索引。
例如，以下代码定义了一个 multi_index_container，用于存储 Person 对象，并创建了两个索引：一个按照 id 排序的有序索引，另一个按照 name 排序的有序索引。
1
#include <boost/multi_index_container.hpp>
2
#include <boost/multi_index/ordered_index.hpp>
3
#include <boost/multi_index/identity.hpp>
4
#include <boost/multi_index/member.hpp>
5
6
using namespace boost::multi_index;
7
8
struct Person {
9
int id;
10
std::string name;
11
int age;
12
13
Person(int id, const std::string& name, int age) : id(id), name(name), age(age) {}
14
15
friend std::ostream& operator<<(std::ostream& os, const Person& person) {
16
os << "ID: " << person.id << ", Name: " << person.name << ", Age: " << person.age;
17
return os;
18
}
19
};
20
21
using PersonContainer = multi_index_container<
22
Person,
23
indexed_by<
24
ordered_unique<
25
member<Person, int, &Person::id> // 按照 id 排序的唯一索引
26
>,
27
ordered_non_unique<
28
member<Person, std::string, &Person::name> // 按照 name 排序的非唯一索引
29
>
30
>
31
>;
在这个例子中，PersonContainer 就是一个 multi_index_container，它存储 Person 类型的对象，并维护了两个索引。
1.2.2 索引 (Index)
索引 (Index) 是 Multi-index 的核心概念。每个索引提供了一种访问容器中元素的方式。multi_index_container 可以包含多个索引，每个索引基于不同的键和排序规则组织数据。
Boost Multi-index 提供了多种索引类型，主要包括：
① 有序索引 (Ordered Indices)：基于键的排序顺序组织元素，类似于 std::set 和 std::map。有序索引支持快速的查找、范围查询和排序遍历。常见的有序索引类型包括 ordered_unique 和 ordered_non_unique。
② 哈希索引 (Hashed Indices)：基于键的哈希值组织元素，类似于 std::unordered_set 和 std::unordered_map。哈希索引提供快速的查找，平均查找时间复杂度为 \(O(1)\)。常见的哈希索引类型包括 hashed_unique 和 hashed_non_unique。
③ 序列索引 (Sequenced Index)：按照元素插入的顺序组织元素，类似于 std::vector 和 std::list。序列索引支持按照插入顺序访问元素。索引类型为 sequenced。
④ 随机访问索引 (Random Access Index)：允许通过索引下标随机访问元素，类似于 std::vector。随机访问索引提供了通过下标快速访问元素的能力。索引类型为 random_access。
在 multi_index_container 的定义中，通过 indexed_by 模板类来指定要创建的索引列表。indexed_by 接受一个或多个索引描述符作为模板参数，每个索引描述符定义了一个索引的类型和属性。
在上面的 PersonContainer 示例中，我们定义了两个索引：
1
indexed_by<
2
ordered_unique<
3
member<Person, int, &Person::id>
4
>,
5
ordered_non_unique<
6
member<Person, std::string, &Person::name>
7
>
8
>
这段代码指定了两个索引：
① 第一个索引是 ordered_unique 类型，它按照 Person 对象的 id 成员进行排序，并且保证 id 的唯一性。
② 第二个索引是 ordered_non_unique 类型，它按照 Person 对象的 name 成员进行排序，允许 name 重复。
每个索引在 multi_index_container 中都有一个索引号 (Index Number)，索引号从 0 开始，依次递增。可以通过索引号来访问和操作特定的索引。例如，第一个索引的索引号为 0，第二个索引的索引号为 1，以此类推。
1.2.3 键提取器 (Key Extractor)
键提取器 (Key Extractor) 用于从容器的元素中提取索引键值 (Index Key)。索引需要根据键值来排序或哈希元素，键提取器就是负责提供这些键值的工具。
Boost Multi-index 提供了多种键提取器，可以灵活地从元素中提取各种类型的键值。常见的键提取器包括：
① identity<>: 当元素本身就是键值时使用。例如，如果容器存储的是整数，并且要按照整数值排序，可以使用 identity<> 作为键提取器。
② member<>: 用于提取元素的成员变量作为键值。例如，在 PersonContainer 示例中，member<Person, int, &Person::id> 就是一个成员指针键提取器，它提取 Person 对象的 id 成员作为键值。
③ global_fun<>(): 用于使用全局函数来提取键值。可以自定义一个全局函数，接受元素作为参数，返回键值。
④ const_mem_fun<>() 和 mem_fun<>(): 用于调用元素的成员函数来提取键值。const_mem_fun<>() 用于调用 const 成员函数，mem_fun<>() 用于调用非 const 成员函数。
⑤ lambda 表达式: 可以使用 C++11 的 lambda 表达式来定义键提取逻辑，更加灵活和简洁。
⑥ composite_key<>(): 用于创建复合键，即使用多个键值组合成一个键。
在索引描述符中，键提取器通常作为模板参数传递给索引类型。例如，在 ordered_unique<member<Person, int, &Person::id>> 中，member<Person, int, &Person::id> 就是 ordered_unique 索引的键提取器。
选择合适的键提取器是使用 Multi-index 的关键步骤之一。键提取器的效率直接影响索引的性能。通常情况下，成员指针键提取器和 lambda 表达式键提取器的性能较高。
1.2.4 排序 (Ordering)
排序 (Ordering) 决定了有序索引中元素的排列顺序。对于有序索引（如 ordered_unique 和 ordered_non_unique），需要指定排序方式。
Boost Multi-index 默认使用 std::less<> 作为排序准则，即升序排列。如果需要自定义排序方式，可以使用自定义的比较函数或函数对象。
可以在索引描述符中通过 排序准则 (Ordering Predicate) 模板参数来指定排序方式。例如，要使用降序排列，可以使用 std::greater<>：
1
ordered_unique<
2
member<Person, int, &Person::id>,
3
std::greater<int> // 使用降序排列
4
>
除了标准的比较函数对象（如 std::less<>、std::greater<>），还可以使用 lambda 表达式或自定义的函数对象作为排序准则。
排序准则的选择会影响索引的性能和行为。选择合适的排序准则可以提高查询效率和满足特定的排序需求。
1.3 第一个 Multi-index 容器 (Your First Multi-index Container)
为了更好地理解 Boost Multi-index 的基本用法，我们来创建一个简单的 Multi-index 容器，并演示其基本操作。
1.3.1 简单的示例代码 (Simple Example Code)
我们将创建一个存储书籍信息的 multi_index_container。每本书籍包含书名（title）、作者（author）和 ISBN（isbn）三个属性。我们将创建两个索引：
① 按照 ISBN 排序的唯一索引，用于通过 ISBN 快速查找书籍。
② 按照作者排序的非唯一索引，用于查找同一作者的所有书籍。
以下是示例代码：
1
#include <iostream>
2
#include <string>
3
#include <boost/multi_index_container.hpp>
4
#include <boost/multi_index/ordered_index.hpp>
5
#include <boost/multi_index/member.hpp>
6
7
using namespace boost::multi_index;
8
9
// 定义书籍结构体
10
struct Book {
11
std::string title;
12
std::string author;
13
std::string isbn;
14
15
Book(const std::string& title, const std::string& author, const std::string& isbn)
16
: title(title), author(author), isbn(isbn) {}
17
18
friend std::ostream& operator<<(std::ostream& os, const Book& book) {
19
os << "Title: " << book.title << ", Author: " << book.author << ", ISBN: " << book.isbn;
20
return os;
21
}
22
};
23
24
// 定义 Multi-index 容器类型
25
using BookContainer = multi_index_container<
26
Book,
27
indexed_by<
28
ordered_unique< // 按照 ISBN 排序的唯一索引
29
member<Book, std::string, &Book::isbn>
30
>,
31
ordered_non_unique< // 按照 author 排序的非唯一索引
32
member<Book, std::string, &Book::author>
33
>
34
>
35
>;
36
37
int main() {
38
// 创建 BookContainer 对象
39
BookContainer book_container;
40
41
// 插入书籍
42
book_container.emplace("The Hitchhiker's Guide to the Galaxy", "Douglas Adams", "978-0345391803");
43
book_container.emplace("The Restaurant at the End of the Universe", "Douglas Adams", "978-0345391810");
44
book_container.emplace("The Lord of the Rings", "J.R.R. Tolkien", "978-0618260269");
45
46
// 获取 ISBN 索引视图
47
const ordered_index<BookContainer>::type& isbn_index = book_container.get<0>();
48
49
// 通过 ISBN 查找书籍
50
auto it_isbn = isbn_index.find("978-0345391803");
51
if (it_isbn != isbn_index.end()) {
52
std::cout << "找到 ISBN 为 978-0345391803 的书籍: " << *it_isbn << std::endl;
53
}
54
55
// 获取 author 索引视图
56
const ordered_index<BookContainer>::type& author_index = book_container.get<1>();
57
58
// 查找 Douglas Adams 的所有书籍
59
auto range = author_index.equal_range("Douglas Adams");
60
std::cout << "Douglas Adams 的书籍: " << std::endl;
61
for (auto it = range.first; it != range.second; ++it) {
62
std::cout << *it << std::endl;
63
}
64
65
return 0;
66
}
这段代码首先定义了 Book 结构体，然后使用 multi_index_container 创建了 BookContainer 类型，并定义了两个索引。在 main 函数中，我们创建了 BookContainer 对象，插入了几本书籍，并演示了如何通过 ISBN 索引和 author 索引查找书籍。
1.3.2 编译和运行 (Compilation and Execution)
要编译和运行上面的示例代码，需要确保已经安装了 Boost 库，并且编译器能够找到 Boost 库的头文件和库文件。
编译命令 (使用 g++):
1
g++ -o multi_index_example multi_index_example.cpp -I/path/to/boost_1_xx_x
请将 /path/to/boost_1_xx_x 替换为你的 Boost 库的安装路径。
运行命令:
1
./multi_index_example
预期输出:
1
找到 ISBN 为 978-0345391803 的书籍: Title: The Hitchhiker's Guide to the Galaxy, Author: Douglas Adams, ISBN: 978-0345391803
2
Douglas Adams 的书籍:
3
Title: The Hitchhiker's Guide to the Galaxy, Author: Douglas Adams, ISBN: 978-0345391803
4
Title: The Restaurant at the End of the Universe, Author: Douglas Adams, ISBN: 978-0345391810
这个简单的示例演示了如何创建一个包含多个索引的 multi_index_container，并使用不同的索引进行查找操作。通过这个例子，读者可以初步了解 Boost Multi-index 的基本用法和优势。在接下来的章节中，我们将深入探讨各种索引类型、键提取器、常用操作和高级特性，帮助读者全面掌握 Boost Multi-index 的使用技巧。
END_OF_CHAPTER
2. chapter 2： 索引类型详解 (Detailed Explanation of Index Types)
在 Boost.MultiIndex 中，索引（Index）是库的核心概念之一。索引类型决定了数据的组织方式和访问特性。选择合适的索引类型对于 Multi-index 容器的性能和功能至关重要。本章将深入探讨 Boost.MultiIndex 提供的各种索引类型，帮助读者理解它们的特点、适用场景以及如何根据实际需求进行选择。
2.1 有序索引 (Ordered Indices)
有序索引（Ordered Indices）是最常用也是最基础的索引类型。它基于键值的排序来组织元素，并提供快速的查找、范围查询等操作。Boost.MultiIndex 提供了两种主要的有序索引：ordered_unique 和 ordered_non_unique。
2.1.1 ordered_unique
ordered_unique 索引类型类似于 std::set 或 std::map，它保证索引中的键值是唯一的，并且元素按照键值排序。
特点：
① 唯一键值：不允许重复的键值存在于索引中。如果尝试插入具有相同键值的元素，则插入操作会失败（或忽略，取决于具体操作）。
② 排序：元素按照键值进行排序，默认是升序排列。排序方式可以通过自定义比较函数或仿函数来指定。
③ 高效查找：由于元素已排序，ordered_unique 索引支持高效的查找操作，如 find、lower_bound、upper_bound 和 equal_range，时间复杂度通常为 \(O(\log N)\)，其中 \(N\) 是容器中元素的数量。
④ 适用场景：适用于需要快速查找特定元素，并保证键值唯一性的场景，例如：
⚝ 用户名管理系统，确保用户名唯一。
⚝ 存储唯一标识符的集合，并需要按标识符排序。
示例代码：
1
#include <boost/multi_index_container.hpp>
2
#include <boost/multi_index/ordered_index.hpp>
3
#include <boost/multi_index/identity.hpp>
4
#include <string>
5
#include <iostream>
6
7
using namespace boost::multi_index;
8
9
struct Employee {
10
int id;
11
std::string name;
12
13
Employee(int id, std::string name) : id(id), name(name) {}
14
15
friend std::ostream& operator<<(std::ostream& os, const Employee& emp) {
16
os << "ID: " << emp.id << ", Name: " << emp.name;
17
return os;
18
}
19
};
20
21
// 定义 multi_index_container，使用 ordered_unique 索引，键为 Employee 的 id
22
typedef multi_index_container<
23
Employee,
24
indexed_by<
25
ordered_unique<
26
identity<Employee>,
27
member<Employee, int, &Employee::id> // 键提取器，提取 Employee 的 id 成员
28
>
29
>
30
> employee_set;
31
32
int main() {
33
employee_set employees;
34
35
employees.insert(Employee(1, "Alice"));
36
employees.insert(Employee(2, "Bob"));
37
employees.insert(Employee(3, "Charlie"));
38
39
// 尝试插入重复 id 的元素，插入失败
40
auto result = employees.insert(Employee(2, "David"));
41
if (!result.second) {
42
std::cout << "Failed to insert employee with duplicate ID." << std::endl;
43
}
44
45
// 查找 id 为 2 的员工
46
auto it = employees.find(2);
47
if (it != employees.end()) {
48
std::cout << "Found employee: " << *it << std::endl;
49
}
50
51
// 遍历所有员工，按 id 排序
52
std::cout << "Employees in order of ID:" << std::endl;
53
for (const auto& emp : employees) {
54
std::cout << emp << std::endl;
55
}
56
57
return 0;
58
}
代码解释：
① 我们定义了一个 Employee 结构体，包含 id 和 name 两个成员。
② 使用 multi_index_container 创建了一个名为 employee_set 的容器。
③ 在 indexed_by 中，我们指定了 ordered_unique 索引。
④ identity<Employee> 表示我们直接使用 Employee 对象作为值。
⑤ member<Employee, int, &Employee::id> 是键提取器，它指定使用 Employee 结构体的 id 成员作为键。
⑥ 在 main 函数中，我们插入了几个 Employee 对象。尝试插入重复 id 的元素时，插入操作失败，因为 ordered_unique 索引保证键的唯一性。
⑦ 使用 find 方法可以根据 id 快速查找员工。
⑧ 遍历容器时，元素会按照 id 的升序排列输出。
2.1.2 ordered_non_unique
ordered_non_unique 索引类型类似于 std::multiset 或 std::multimap，它允许索引中存在重复的键值，并且元素按照键值排序。
特点：
① 非唯一键值：允许重复的键值存在于索引中。可以插入多个具有相同键值的元素。
② 排序：元素按照键值进行排序，默认是升序排列。排序方式同样可以通过自定义比较函数或仿函数来指定。
③ 高效查找：与 ordered_unique 类似，ordered_non_unique 也支持高效的查找操作，如 find、lower_bound、upper_bound 和 equal_range，时间复杂度通常为 \(O(\log N)\)。equal_range 在处理重复键值时尤其有用，它可以返回所有具有相同键值的元素的范围。
④ 适用场景：适用于需要存储可能重复的元素，并需要按键值排序和范围查询的场景，例如：
⚝ 记录事件发生时间的时间轴，同一时间可能发生多个事件。
⚝ 存储学生的考试成绩，可能存在多个学生成绩相同的情况，需要按成绩排序并统计某个分数段的学生人数。
示例代码：
1
#include <boost/multi_index_container.hpp>
2
#include <boost/multi_index/ordered_index.hpp>
3
#include <boost/multi_index/identity.hpp>
4
#include <string>
5
#include <iostream>
6
7
using namespace boost::multi_index;
8
9
struct LogEntry {
10
int timestamp;
11
std::string message;
12
13
LogEntry(int timestamp, std::string message) : timestamp(timestamp), message(message) {}
14
15
friend std::ostream& operator<<(std::ostream& os, const LogEntry& log) {
16
os << "Timestamp: " << log.timestamp << ", Message: " << log.message;
17
return os;
18
}
19
};
20
21
// 定义 multi_index_container，使用 ordered_non_unique 索引，键为 LogEntry 的 timestamp
22
typedef multi_index_container<
23
LogEntry,
24
indexed_by<
25
ordered_non_unique<
26
identity<LogEntry>,
27
member<LogEntry, int, &LogEntry::timestamp> // 键提取器，提取 LogEntry 的 timestamp 成员
28
>
29
>
30
> log_set;
31
32
int main() {
33
log_set logs;
34
35
logs.insert(LogEntry(100, "System started"));
36
logs.insert(LogEntry(101, "User login"));
37
logs.insert(LogEntry(101, "Data backup started")); // 同一时间戳的日志
38
logs.insert(LogEntry(102, "Data backup finished"));
39
40
// 查找时间戳为 101 的所有日志
41
auto range = logs.equal_range(101);
42
std::cout << "Logs at timestamp 101:" << std::endl;
43
for (auto it = range.first; it != range.second; ++it) {
44
std::cout << *it << std::endl;
45
}
46
47
// 遍历所有日志，按时间戳排序
48
std::cout << "Logs in order of timestamp:" << std::endl;
49
for (const auto& log : logs) {
50
std::cout << log << std::endl;
51
}
52
53
return 0;
54
}
代码解释：
① 我们定义了一个 LogEntry 结构体，包含 timestamp 和 message 两个成员。
② 使用 multi_index_container 创建了一个名为 log_set 的容器，使用 ordered_non_unique 索引，键为 LogEntry 的 timestamp 成员。
③ 在 main 函数中，我们插入了几个 LogEntry 对象，包括两个时间戳相同的日志。
④ 使用 equal_range 方法可以查找所有时间戳为 101 的日志，返回一个迭代器范围，包含了所有键值为 101 的元素。
⑤ 遍历容器时，元素会按照 timestamp 的升序排列输出，并且时间戳相同的日志会相邻排列。
2.2 哈希索引 (Hashed Indices)
哈希索引（Hashed Indices）使用哈希表来组织元素，提供平均常数时间复杂度的查找、插入和删除操作。Boost.MultiIndex 提供了 hashed_unique 和 hashed_non_unique 两种哈希索引。
2.2.1 hashed_unique
hashed_unique 索引类型类似于 std::unordered_set 或 std::unordered_map，它保证索引中的键值是唯一的，并使用哈希表实现快速查找。
特点：
① 唯一键值：与 ordered_unique 类似，hashed_unique 索引也保证键值的唯一性。
② 哈希表实现：使用哈希表作为底层数据结构，提供平均 \(O(1)\) 时间复杂度的插入、删除和查找操作。最坏情况下，时间复杂度可能退化到 \(O(N)\)，但这在实际应用中很少发生，前提是哈希函数设计良好且哈希表负载因子控制在合理范围内。
③ 无序：哈希索引中的元素不保证任何特定的顺序。迭代器遍历元素的顺序是不确定的，通常与元素的插入顺序无关。
④ 适用场景：适用于对元素顺序没有要求，但需要快速查找、插入和删除操作，并保证键值唯一性的场景，例如：
⚝ 快速检查某个元素是否已存在于集合中。
⚝ 实现缓存系统，需要快速查找和添加缓存项，并保证缓存键的唯一性。
示例代码：
1
#include <boost/multi_index_container.hpp>
2
#include <boost/multi_index/hashed_index.hpp>
3
#include <boost/multi_index/identity.hpp>
4
#include <string>
5
#include <iostream>
6
7
using namespace boost::multi_index;
8
9
struct Product {
10
std::string sku; // SKU (Stock Keeping Unit)
11
std::string name;
12
double price;
13
14
Product(std::string sku, std::string name, double price) : sku(sku), name(name), price(price) {}
15
16
friend std::ostream& operator<<(std::ostream& os, const Product& prod) {
17
os << "SKU: " << prod.sku << ", Name: " << prod.name << ", Price: " << prod.price;
18
return os;
19
}
20
};
21
22
// 定义 multi_index_container，使用 hashed_unique 索引，键为 Product 的 sku
23
typedef multi_index_container<
24
Product,
25
indexed_by<
26
hashed_unique<
27
identity<Product>,
28
member<Product, std::string, &Product::sku> // 键提取器，提取 Product 的 sku 成员
29
>
30
>
31
> product_set;
32
33
int main() {
34
product_set products;
35
36
products.insert(Product("P1001", "Laptop", 1200.0));
37
products.insert(Product("P1002", "Mouse", 25.0));
38
products.insert(Product("P1003", "Keyboard", 75.0));
39
40
// 尝试插入重复 sku 的产品，插入失败
41
auto result = products.insert(Product("P1002", "Monitor", 300.0));
42
if (!result.second) {
43
std::cout << "Failed to insert product with duplicate SKU." << std::endl;
44
}
45
46
// 查找 sku 为 "P1002" 的产品
47
auto it = products.find("P1002");
48
if (it != products.end()) {
49
std::cout << "Found product: " << *it << std::endl;
50
}
51
52
// 遍历所有产品，顺序不确定
53
std::cout << "Products (unordered):" << std::endl;
54
for (const auto& prod : products) {
55
std::cout << prod << std::endl;
56
}
57
58
return 0;
59
}
代码解释：
① 我们定义了一个 Product 结构体，包含 sku、name 和 price 成员。
② 使用 multi_index_container 创建了一个名为 product_set 的容器，使用 hashed_unique 索引，键为 Product 的 sku 成员。
③ 在 main 函数中，我们插入了几个 Product 对象。尝试插入重复 sku 的产品时，插入操作失败。
④ 使用 find 方法可以根据 sku 快速查找产品。
⑤ 遍历容器时，元素的输出顺序是不确定的，因为哈希索引不保证元素顺序。
2.2.2 hashed_non_unique
hashed_non_unique 索引类型类似于 std::unordered_multiset 或 std::unordered_multimap，它允许索引中存在重复的键值，并使用哈希表实现快速查找。
特点：
① 非唯一键值：允许重复的键值存在于索引中。
② 哈希表实现：同样使用哈希表作为底层数据结构，提供平均 \(O(1)\) 时间复杂度的插入、删除和查找操作。
③ 无序：元素顺序不确定。
④ 适用场景：适用于需要快速插入、删除和查找操作，允许重复键值，且对元素顺序没有要求的场景，例如：
⚝ 统计词频，可以使用哈希索引存储单词，允许重复单词出现，并快速统计每个单词的出现次数。
⚝ 记录用户行为日志，同一用户可能产生多条行为日志，需要快速记录和查询特定用户的行为日志。
示例代码：
1
#include <boost/multi_index_container.hpp>
2
#include <boost/multi_index/hashed_index.hpp>
3
#include <boost/multi_index/identity.hpp>
4
#include <string>
5
#include <iostream>
6
7
using namespace boost::multi_index;
8
9
struct Keyword {
10
std::string word;
11
12
Keyword(std::string word) : word(word) {}
13
14
friend std::ostream& operator<<(std::ostream& os, const Keyword& kw) {
15
os << "Word: " << kw.word;
16
return os;
17
}
18
};
19
20
// 定义 multi_index_container，使用 hashed_non_unique 索引，键为 Keyword 的 word
21
typedef multi_index_container<
22
Keyword,
23
indexed_by<
24
hashed_non_unique<
25
identity<Keyword>,
26
member<Keyword, std::string, &Keyword::word> // 键提取器，提取 Keyword 的 word 成员
27
>
28
>
29
> keyword_set;
30
31
int main() {
32
keyword_set keywords;
33
34
keywords.insert(Keyword("boost"));
35
keywords.insert(Keyword("multi_index"));
36
keywords.insert(Keyword("boost")); // 重复的关键词
37
keywords.insert(Keyword("container"));
38
39
// 统计 "boost" 关键词的出现次数
40
size_t count = keywords.count("boost");
41
std::cout << "Count of 'boost': " << count << std::endl;
42
43
// 查找 "boost" 关键词的所有实例
44
auto range = keywords.equal_range("boost");
45
std::cout << "Instances of 'boost':" << std::endl;
46
for (auto it = range.first; it != range.second; ++it) {
47
std::cout << *it << std::endl;
48
}
49
50
// 遍历所有关键词，顺序不确定
51
std::cout << "Keywords (unordered):" << std::endl;
52
for (const auto& kw : keywords) {
53
std::cout << kw << std::endl;
54
}
55
56
return 0;
57
}
代码解释：
① 我们定义了一个 Keyword 结构体，包含 word 成员。
② 使用 multi_index_container 创建了一个名为 keyword_set 的容器，使用 hashed_non_unique 索引，键为 Keyword 的 word 成员。
③ 在 main 函数中，我们插入了几个 Keyword 对象，包括重复的关键词 "boost"。
④ 使用 count 方法可以统计特定关键词的出现次数。
⑤ 使用 equal_range 方法可以查找所有键值为 "boost" 的元素。
⑥ 遍历容器时，元素的输出顺序是不确定的。
2.3 序列索引 (Sequenced Indices) - sequenced
序列索引（Sequenced Indices） sequenced 提供了类似于 std::list 或 std::deque 的功能，它按照元素的插入顺序维护元素的序列，并支持快速的插入和删除操作，尤其是在序列的头部和尾部。
特点：
① 插入顺序：元素按照插入容器的顺序进行存储和维护。
② 双向链表实现：底层通常使用双向链表或类似的数据结构实现，支持 \(O(1)\) 时间复杂度的在任意位置插入和删除元素（已知迭代器的情况下），以及在头部和尾部进行插入和删除。
③ 迭代器稳定性：除了删除操作，序列索引的迭代器在容器进行插入和删除操作时仍然有效（指向的元素不变）。
④ 适用场景：适用于需要维护元素插入顺序，并频繁进行插入和删除操作的场景，例如：
⚝ 实现任务队列或消息队列，需要按照任务到达的顺序处理任务。
⚝ 维护最近访问过的文件列表，需要按照访问时间顺序排列，并快速添加和删除文件。
示例代码：
1
#include <boost/multi_index_container.hpp>
2
#include <boost/multi_index/sequenced_index.hpp>
3
#include <boost/multi_index/identity.hpp>
4
#include <string>
5
#include <iostream>
6
7
using namespace boost::multi_index;
8
9
struct Task {
10
std::string description;
11
12
Task(std::string description) : description(description) {}
13
14
friend std::ostream& operator<<(std::ostream& os, const Task& task) {
15
os << "Description: " << task.description;
16
return os;
17
}
18
};
19
20
// 定义 multi_index_container，使用 sequenced 索引
21
typedef multi_index_container<
22
Task,
23
indexed_by<
24
sequenced<> // sequenced 索引，按插入顺序维护元素
25
>
26
> task_list;
27
28
int main() {
29
task_list tasks;
30
31
tasks.push_back(Task("Implement feature A"));
32
tasks.push_back(Task("Fix bug #123"));
33
tasks.push_back(Task("Write documentation"));
34
35
// 遍历所有任务，按插入顺序输出
36
std::cout << "Tasks in insertion order:" << std::endl;
37
for (const auto& task : tasks) {
38
std::cout << *task << std::endl;
39
}
40
41
// 在头部插入任务
42
tasks.push_front(Task("Review code"));
43
44
std::cout << "Tasks after inserting at front:" << std::endl;
45
for (const auto& task : tasks) {
46
std::cout << *task << std::endl;
47
}
48
49
return 0;
50
}
代码解释：
① 我们定义了一个 Task 结构体，包含 description 成员。
② 使用 multi_index_container 创建了一个名为 task_list 的容器，使用 sequenced<> 索引。
③ 在 main 函数中，我们使用 push_back 方法向容器尾部添加任务。
④ 遍历容器时，元素按照插入顺序输出。
⑤ 使用 push_front 方法可以在容器头部插入任务。
2.4 随机访问索引 (Random Access Indices) - random_access
随机访问索引（Random Access Indices） random_access 提供了类似于 std::vector 或 std::deque 的功能，它允许通过索引位置快速访问元素，并支持在序列尾部快速插入和删除操作。
特点：
① 索引访问：支持通过下标（索引位置）直接访问元素，例如 container[index]，提供 \(O(1)\) 时间复杂度的随机访问。
② 动态数组实现：底层通常使用动态数组或类似的数据结构实现。
③ 尾部快速操作：在尾部进行插入和删除操作的时间复杂度为 \(O(1)\) （均摊）。在头部或中间位置插入和删除元素的时间复杂度为 \(O(N)\)，因为需要移动后续元素。
④ 适用场景：适用于需要通过索引位置快速访问元素，并主要在尾部进行插入和删除操作的场景，例如：
⚝ 存储需要按索引访问的数据集合，例如数组或列表。
⚝ 实现日志缓冲区，需要按顺序记录日志，并可以通过索引访问特定位置的日志。
示例代码：
1
#include <boost/multi_index_container.hpp>
2
#include <boost/multi_index/random_access_index.hpp>
3
#include <boost/multi_index/identity.hpp>
4
#include <string>
5
#include <iostream>
6
7
using namespace boost::multi_index;
8
9
struct Event {
10
std::string description;
11
12
Event(std::string description) : description(description) {}
13
14
friend std::ostream& operator<<(std::ostream& os, const Event& event) {
15
os << "Description: " << event.description;
16
return os;
17
}
18
};
19
20
// 定义 multi_index_container，使用 random_access 索引
21
typedef multi_index_container<
22
Event,
23
indexed_by<
24
random_access<> // random_access 索引，支持索引访问
25
>
26
> event_list;
27
28
int main() {
29
event_list events;
30
31
events.push_back(Event("Event A occurred"));
32
events.push_back(Event("Event B occurred"));
33
events.push_back(Event("Event C occurred"));
34
35
// 通过索引访问元素
36
std::cout << "Event at index 1: " << events[1] << std::endl;
37
38
// 遍历所有事件，按索引顺序输出
39
std::cout << "Events in index order:" << std::endl;
40
for (size_t i = 0; i < events.size(); ++i) {
41
std::cout << "Index " << i << ": " << events[i] << std::endl;
42
}
43
44
return 0;
45
}
代码解释：
① 我们定义了一个 Event 结构体，包含 description 成员。
② 使用 multi_index_container 创建了一个名为 event_list 的容器，使用 random_access<> 索引。
③ 在 main 函数中，我们使用 push_back 方法向容器尾部添加事件。
④ 可以使用下标运算符 [] 通过索引访问容器中的元素。
⑤ 遍历容器时，元素按照索引顺序输出。
2.5 选择合适的索引类型 (Choosing the Right Index Type)
选择合适的索引类型是使用 Boost.MultiIndex 的关键。不同的索引类型适用于不同的应用场景，并具有不同的性能特点。以下是一些选择索引类型的指导原则：
① 是否需要排序？
▮▮▮▮⚝ 如果需要按键值排序并进行范围查询，则选择 有序索引 (ordered_unique 或 ordered_non_unique)。
▮▮▮▮⚝ 如果不需要排序，但需要快速查找，则考虑 哈希索引 (hashed_unique 或 hashed_non_unique)。
▮▮▮▮⚝ 如果需要维护插入顺序，则选择 序列索引 (sequenced)。
▮▮▮▮⚝ 如果需要通过索引位置快速访问元素，则选择 随机访问索引 (random_access)。
② 键值是否唯一？
▮▮▮▮⚝ 如果键值必须唯一，则选择 _unique 类型的索引 (ordered_unique 或 hashed_unique)。
▮▮▮▮⚝ 如果键值可以重复，则选择 _non_unique 类型的索引 (ordered_non_unique 或 hashed_non_unique)。
③ 性能需求
▮▮▮▮⚝ 查找性能：
▮▮▮▮⚝ 有序索引和哈希索引都提供高效的查找性能。有序索引的查找时间复杂度为 \(O(\log N)\)，哈希索引的平均查找时间复杂度为 \(O(1)\)。
▮▮▮▮⚝ 如果对查找性能要求非常高，且数据量很大，哈希索引通常更快，但需要考虑哈希冲突和哈希函数的设计。
▮▮▮▮⚝ 插入和删除性能：
▮▮▮▮⚝ 哈希索引的平均插入和删除时间复杂度为 \(O(1)\)。
▮▮▮▮⚝ 有序索引的插入和删除时间复杂度为 \(O(\log N)\)。
▮▮▮▮⚝ 序列索引和随机访问索引在序列尾部进行插入和删除操作的时间复杂度为 \(O(1)\)，但在头部或中间位置操作可能较慢。
▮▮▮▮⚝ 内存占用：
▮▮▮▮⚝ 哈希索引通常比有序索引占用更多的内存，因为哈希表需要额外的空间来存储桶（buckets）和维护哈希表结构。
▮▮▮▮⚝ 序列索引和随机访问索引的内存占用取决于存储的元素数量。
④ 迭代器特性
▮▮▮▮⚝ 有序索引提供按键值排序的迭代器。
▮▮▮▮⚝ 哈希索引的迭代器遍历顺序不确定。
▮▮▮▮⚝ 序列索引的迭代器按插入顺序遍历元素。
▮▮▮▮⚝ 随机访问索引的迭代器按索引顺序遍历元素。
在实际应用中，可能需要根据具体的业务需求和性能指标，综合考虑各种因素，选择最合适的索引类型。在某些复杂场景下，甚至可以组合使用多种索引类型，以满足不同的查询和操作需求。后续章节将通过实战案例进一步展示如何根据实际问题选择和应用不同的索引类型。
END_OF_CHAPTER
3. chapter 3： 键提取器 (Key Extractors)
在 Boost Multi-index 容器中，键提取器 (Key Extractor) 是一个至关重要的概念。它定义了如何从存储在容器中的对象中提取用于索引的键值。简单来说，键提取器就像一个“函数”，它告诉 Multi-index 容器，对于容器中的每个元素，应该使用元素的哪个部分（或如何计算得到）作为索引的键。
3.1 默认键提取器 (Default Key Extractor)
在最简单的情况下，当我们创建一个 Multi-index 容器时，如果没有显式指定键提取器，Multi-index 会使用默认键提取器 (Default Key Extractor)。默认键提取器假定容器直接存储键值本身，而不是复杂的对象。
例如，如果我们创建一个存储 int 类型的 ordered_unique 索引的 Multi-index 容器，那么 int 值本身就被视为键。
1
#include <boost/multi_index_container.hpp>
2
#include <boost/multi_index/ordered_index.hpp>
3
#include <boost/multi_index/identity.hpp>
4
#include <iostream>
5
6
using namespace boost::multi_index;
7
8
int main() {
9
// 创建一个 multi_index_container，使用 ordered_unique 索引，存储 int 类型
10
multi_index_container<
11
int, // 存储 int 类型的值
12
indexed_by<
13
ordered_unique<identity<int>> // 使用 ordered_unique 索引，键提取器为 identity<int>
14
>
15
> int_set;
16
17
int_set.insert(3);
18
int_set.insert(1);
19
int_set.insert(4);
20
int_set.insert(1); // 重复插入，ordered_unique 索引会忽略
21
22
// 遍历容器
23
for (const auto& val : int_set) {
24
std::cout << val << " "; // 输出：1 3 4
25
}
26
std::cout << std::endl;
27
28
return 0;
29
}
在这个例子中，identity<int> 就是默认键提取器。identity<T> 是 Boost.MultiIndex 提供的一个简单的键提取器，它直接返回对象本身作为键。当容器存储的是基本类型（如 int, std::string）或者你希望直接使用存储的对象作为键时，默认键提取器非常方便。
identity<T> 的作用:
identity<T> 实际上是一个仿函数（Functor），它接受一个类型为 T 的参数，并返回该参数本身。在 Multi-index 的上下文中，它告诉索引机制：“直接使用容器中存储的值作为索引键”。
适用场景:
⚝ 容器直接存储键值，例如 std::set 的行为。
⚝ 键值类型是基本类型或已经重载了比较运算符的自定义类型。
总结:
默认键提取器 identity<T> 简化了 Multi-index 容器的创建，尤其是在处理简单数据类型或需要直接使用存储对象作为键的场景下。它避免了显式定义键提取器的繁琐，使得代码更加简洁易懂。
3.2 成员指针键提取器 (Member Pointer Key Extractor) - member
当 Multi-index 容器存储的是自定义的类或结构体对象，并且我们希望使用对象的成员变量作为索引键时，就需要使用成员指针键提取器 (Member Pointer Key Extractor)，即 member。
member 允许我们指定一个指向类成员的指针，Multi-index 将会通过这个指针从容器中的每个对象中提取键值。
示例：学生信息管理
假设我们有一个 Student 类，包含学生的姓名 (name) 和学号 (id)：
1
#include <string>
2
3
class Student {
4
public:
5
std::string name;
6
int id;
7
8
Student(std::string n, int i) : name(n), id(i) {}
9
10
friend std::ostream& operator<<(std::ostream& os, const Student& student) {
11
os << "Name: " << student.name << ", ID: " << student.id;
12
return os;
13
}
14
};
现在，我们想要创建一个 Multi-index 容器来存储 Student 对象，并分别使用学生的 id 和 name 作为索引。我们可以使用 member 键提取器来实现：
1
#include <boost/multi_index_container.hpp>
2
#include <boost/multi_index/ordered_index.hpp>
3
#include <boost/multi_index/member.hpp>
4
#include <string>
5
#include <iostream>
6
7
using namespace boost::multi_index;
8
9
class Student { // Student 类定义 (同上)
10
public:
11
std::string name;
12
int id;
13
14
Student(std::string n, int i) : name(n), id(i) {}
15
16
friend std::ostream& operator<<(std::ostream& os, const Student& student) {
17
os << "Name: " << student.name << ", ID: " << student.id;
18
return os;
19
}
20
};
21
22
23
int main() {
24
// 创建 multi_index_container，存储 Student 对象
25
multi_index_container<
26
Student,
27
indexed_by<
28
ordered_unique<member<Student, int, &Student::id>>, // 使用 id 排序的唯一索引
29
ordered_non_unique<member<Student, std::string, &Student::name>> // 使用 name 排序的非唯一索引
30
>
31
> student_container;
32
33
student_container.insert({"Alice", 1001});
34
student_container.insert({"Bob", 1002});
35
student_container.insert({"Charlie", 1003});
36
student_container.insert({"David", 1002}); // David 和 Bob 的 id 相同，但 name 不同，可以插入 (ordered_non_unique<name>)
37
38
// 通过 id 索引查找
39
auto& id_index = student_container.get<0>(); // 获取第一个索引 (id 索引)
40
auto it_id = id_index.find(1002);
41
if (it_id != id_index.end()) {
42
std::cout << "找到 ID 为 1002 的学生: " << *it_id << std::endl; // 输出：找到 ID 为 1002 的学生: Name: Bob, ID: 1002
43
}
44
45
// 通过 name 索引查找
46
auto& name_index = student_container.get<1>(); // 获取第二个索引 (name 索引)
47
auto it_name = name_index.find("Charlie");
48
if (it_name != name_index.end()) {
49
std::cout << "找到名字为 Charlie 的学生: " << *it_name << std::endl; // 输出：找到名字为 Charlie 的学生: Name: Charlie, ID: 1003
50
}
51
52
return 0;
53
}
代码解析:
⚝ ordered_unique<member<Student, int, &Student::id>>: 定义了一个 ordered_unique 索引，使用 member 键提取器。
▮▮▮▮⚝ Student: 指定容器存储的对象类型是 Student。
▮▮▮▮⚝ int: 指定键的类型是 int (因为 Student::id 是 int 类型)。
▮▮▮▮⚝ &Student::id: 关键部分，这是一个指向 Student 类的 id 成员变量的指针。member 键提取器会使用这个指针从 Student 对象中提取 id 值作为索引键。
⚝ ordered_non_unique<member<Student, std::string, &Student::name>>: 类似地，定义了一个 ordered_non_unique 索引，使用 name 成员变量作为键。
member<Class, KeyType, MemberPtr> 的构成:
⚝ Class: 容器存储的对象的类类型。
⚝ KeyType: 成员变量的类型，也是索引键的类型。
⚝ MemberPtr: 指向 Class 类中 KeyType 类型成员变量的指针。
适用场景:
⚝ 当容器存储自定义类的对象。
⚝ 需要使用对象的成员变量作为索引键进行查找、排序等操作。
⚝ 成员变量是公开的 (public) 或者可以通过友元访问。
总结:
member 键提取器是处理类对象时最常用的键提取器之一。它简洁明了，直接通过成员指针指定键的来源，使得我们可以方便地基于对象的不同成员创建索引，实现多维度的数据访问和管理。
3.3 全局函数键提取器 (Global Function Key Extractor) - global_fun
全局函数键提取器 (Global Function Key Extractor) global_fun 允许我们使用全局函数来提取索引键。这在键的计算逻辑比较复杂，或者需要复用已有的全局函数时非常有用。
示例：使用全局函数计算学生成绩等级
假设我们需要根据学生的成绩计算等级（例如，90 分以上为 'A'，80-89 为 'B'，等等），并将等级作为索引键。我们可以定义一个全局函数来实现这个等级计算逻辑：
1
#include <string>
2
3
class Student { // Student 类定义 (同上)
4
public:
5
std::string name;
6
int score;
7
8
Student(std::string n, int s) : name(n), score(s) {}
9
10
friend std::ostream& operator<<(std::ostream& os, const Student& student) {
11
os << "Name: " << student.name << ", Score: " << student.score;
12
return os;
13
}
14
};
15
16
17
// 全局函数：根据分数计算等级
18
char get_grade(const Student& student) {
19
if (student.score >= 90) return 'A';
20
if (student.score >= 80) return 'B';
21
if (student.score >= 70) return 'C';
22
return 'D';
23
}
现在，我们可以使用 global_fun 键提取器，将 get_grade 函数应用于 Student 对象，提取学生的成绩等级作为索引键：
1
#include <boost/multi_index_container.hpp>
2
#include <boost/multi_index/ordered_index.hpp>
3
#include <boost/multi_index/global_fun.hpp>
4
#include <string>
5
#include <iostream>
6
7
using namespace boost::multi_index;
8
9
class Student { // Student 类定义 (同上)
10
public:
11
std::string name;
12
int score;
13
14
Student(std::string n, int s) : name(n), score(s) {}
15
16
friend std::ostream& operator<<(std::ostream& os, const Student& student) {
17
os << "Name: " << student.name << ", Score: " << student.score;
18
return os;
19
}
20
};
21
22
23
// 全局函数：根据分数计算等级 (同上)
24
char get_grade(const Student& student) {
25
if (student.score >= 90) return 'A';
26
if (student.score >= 80) return 'B';
27
if (student.score >= 70) return 'C';
28
return 'D';
29
}
30
31
32
int main() {
33
// 创建 multi_index_container，存储 Student 对象
34
multi_index_container<
35
Student,
36
indexed_by<
37
ordered_non_unique<global_fun<Student, char, get_grade>> // 使用 get_grade 函数提取等级作为键
38
>
39
> student_container;
40
41
student_container.insert({"Alice", 85});
42
student_container.insert({"Bob", 92});
43
student_container.insert({"Charlie", 78});
44
student_container.insert({"David", 88});
45
46
// 通过等级 'B' 查找学生
47
auto& grade_index = student_container.get<0>(); // 获取第一个索引 (等级索引)
48
auto range = grade_index.equal_range('B'); // 查找等级为 'B' 的范围
49
50
std::cout << "等级为 'B' 的学生: " << std::endl;
51
for (auto it = range.first; it != range.second; ++it) {
52
std::cout << *it << std::endl;
53
// 输出：
54
// 等级为 'B' 的学生:
55
// Name: Alice, Score: 85
56
// Name: David, Score: 88
57
}
58
59
return 0;
60
}
代码解析:
⚝ ordered_non_unique<global_fun<Student, char, get_grade>>: 定义了一个 ordered_non_unique 索引，使用 global_fun 键提取器。
▮▮▮▮⚝ Student: 指定容器存储的对象类型是 Student。
▮▮▮▮⚝ char: 指定键的类型是 char (因为 get_grade 函数返回 char 类型)。
▮▮▮▮⚝ get_grade: 关键部分，这是我们定义的全局函数 get_grade，global_fun 键提取器会调用这个函数，并将容器中的 Student 对象作为参数传递给它，函数的返回值将作为索引键。
global_fun<Class, KeyType, FunctionPtr> 的构成:
⚝ Class: 容器存储的对象的类类型。
⚝ KeyType: 全局函数返回的键的类型。
⚝ FunctionPtr: 指向全局函数的指针，该函数接受 Class 类型的参数，并返回 KeyType 类型的值。
适用场景:
⚝ 当键的计算逻辑比较复杂，不适合直接使用成员变量。
⚝ 需要复用已有的全局函数作为键提取逻辑。
⚝ 键的计算依赖于多个成员变量或者需要进行复杂的运算。
总结:
global_fun 键提取器提供了更大的灵活性，允许我们使用自定义的全局函数来提取键值。这使得我们可以处理更复杂的键提取逻辑，并且可以方便地复用已有的函数，提高代码的可维护性和复用性。
3.4 仿函数键提取器 (Functor Key Extractor) - const_mem_fun, mem_fun
仿函数键提取器 (Functor Key Extractor) 允许我们使用类成员函数（仿函数）来提取索引键。Boost.MultiIndex 提供了两种仿函数键提取器：
⚝ const_mem_fun: 用于常量成员函数，即不会修改对象状态的成员函数。
⚝ mem_fun: 用于非常量成员函数，即可能会修改对象状态的成员函数（通常不建议用于键提取，除非有特殊需求）。
示例：使用成员函数获取学生姓名首字母
假设 Student 类有一个成员函数 get_initial()，用于返回学生姓名的首字母：
1
#include <string>
2
3
class Student { // Student 类定义 (同上)
4
public:
5
std::string name;
6
int id;
7
8
Student(std::string n, int i) : name(n), id(i) {}
9
10
char get_initial() const { // 常量成员函数，返回姓名首字母
11
if (!name.empty()) {
12
return std::toupper(name[0]); // 返回大写首字母
13
}
14
return '?'; // 姓名为空时返回 '?'
15
}
16
17
friend std::ostream& operator<<(std::ostream& os, const Student& student) {
18
os << "Name: " << student.name << ", ID: " << student.id;
19
return os;
20
}
21
};
我们可以使用 const_mem_fun 键提取器，调用 get_initial() 成员函数来提取学生姓名的首字母作为索引键：
1
#include <boost/multi_index_container.hpp>
2
#include <boost/multi_index/ordered_index.hpp>
3
#include <boost/multi_index/mem_fun.hpp> // 注意包含 mem_fun.hpp，而不是 global_fun.hpp
4
#include <string>
5
#include <iostream>
6
7
using namespace boost::multi_index;
8
9
class Student { // Student 类定义 (同上)
10
public:
11
std::string name;
12
int id;
13
14
Student(std::string n, int i) : name(n), id(i) {}
15
16
char get_initial() const { // 常量成员函数，返回姓名首字母 (同上)
17
if (!name.empty()) {
18
return std::toupper(name[0]); // 返回大写首字母
19
}
20
return '?'; // 姓名为空时返回 '?'
21
}
22
23
friend std::ostream& operator<<(std::ostream& os, const Student& student) {
24
os << "Name: " << student.name << ", ID: " << student.id;
25
return os;
26
}
27
};
28
29
30
int main() {
31
// 创建 multi_index_container，存储 Student 对象
32
multi_index_container<
33
Student,
34
indexed_by<
35
ordered_non_unique<const_mem_fun<Student, char, &Student::get_initial>> // 使用 get_initial() 成员函数提取首字母
36
>
37
> student_container;
38
39
student_container.insert({"Alice", 1001});
40
student_container.insert({"Bob", 1002});
41
student_container.insert({"Charlie", 1003});
42
student_container.insert({"Amy", 1004}); // Amy 和 Alice 首字母相同
43
44
// 通过首字母 'A' 查找学生
45
auto& initial_index = student_container.get<0>(); // 获取第一个索引 (首字母索引)
46
auto range = initial_index.equal_range('A'); // 查找首字母为 'A' 的范围
47
48
std::cout << "姓名首字母为 'A' 的学生: " << std::endl;
49
for (auto it = range.first; it != range.second; ++it) {
50
std::cout << *it << std::endl;
51
// 输出：
52
// 姓名首字母为 'A' 的学生:
53
// Name: Alice, ID: 1001
54
// Name: Amy, ID: 1004
55
}
56
57
return 0;
58
}
代码解析:
⚝ ordered_non_unique<const_mem_fun<Student, char, &Student::get_initial>>: 定义了一个 ordered_non_unique 索引，使用 const_mem_fun 键提取器。
▮▮▮▮⚝ Student: 指定容器存储的对象类型是 Student。
▮▮▮▮⚝ char: 指定键的类型是 char (因为 get_initial() 函数返回 char 类型)。
▮▮▮▮⚝ &Student::get_initial: 关键部分，这是一个指向 Student 类的 get_initial() 常量成员函数的指针。const_mem_fun 键提取器会调用这个成员函数，并将容器中的 Student 对象作为 this 指针传递给它，函数的返回值将作为索引键。
const_mem_fun<Class, KeyType, MemberFunctionPtr> 和 mem_fun<Class, KeyType, MemberFunctionPtr> 的构成:
⚝ Class: 容器存储的对象的类类型。
⚝ KeyType: 成员函数返回的键的类型。
⚝ MemberFunctionPtr: 指向 Class 类中成员函数的指针，该函数是常量成员函数 (const_mem_fun) 或非常量成员函数 (mem_fun)，不接受任何参数，并返回 KeyType 类型的值。
适用场景:
⚝ 当键的计算逻辑封装在类的成员函数中。
⚝ 需要使用对象的成员函数来提取键值。
⚝ 成员函数是常量成员函数 (const_mem_fun) 或在特殊情况下可以使用非常量成员函数 (mem_fun)。
选择 const_mem_fun 还是 mem_fun:
⚝ 优先使用 const_mem_fun: 因为键提取操作通常应该是只读的，不应该修改对象的状态。使用常量成员函数可以保证这一点，并提高代码的安全性。
⚝ 谨慎使用 mem_fun: 只有在键提取逻辑必须修改对象状态，并且你明确知道这样做不会引起问题的情况下，才应该使用 mem_fun。这种情况非常少见，通常应该避免使用 mem_fun 作为键提取器。
总结:
const_mem_fun 和 mem_fun 键提取器提供了使用类成员函数作为键提取逻辑的能力。const_mem_fun 是更安全和推荐的选择，它允许我们利用对象自身的行为来定义键，使得键提取逻辑更加贴近对象的设计和功能。
3.5 lambda 表达式键提取器 (Lambda Expression Key Extractor)
lambda 表达式键提取器 (Lambda Expression Key Extractor) 是 C++11 引入 lambda 表达式后，Boost.MultiIndex 提供的一种非常灵活和强大的键提取方式。它允许我们直接在 indexed_by 声明中定义键提取逻辑，无需预先定义全局函数或成员函数。
示例：使用 lambda 表达式提取学生姓名长度
假设我们需要根据学生姓名的长度来索引 Student 对象。我们可以使用 lambda 表达式来定义键提取逻辑，直接计算姓名的长度：
1
#include <boost/multi_index_container.hpp>
2
#include <boost/multi_index/ordered_index.hpp>
3
#include <boost/multi_index/lambda.hpp> // 包含 lambda.hpp
4
#include <string>
5
#include <iostream>
6
7
using namespace boost::multi_index;
8
9
class Student { // Student 类定义 (同上)
10
public:
11
std::string name;
12
int id;
13
14
Student(std::string n, int i) : name(n), id(i) {}
15
16
friend std::ostream& operator<<(std::ostream& os, const Student& student) {
17
os << "Name: " << student.name << ", ID: " << student.id;
18
return os;
19
}
20
};
21
22
23
int main() {
24
// 创建 multi_index_container，存储 Student 对象
25
multi_index_container<
26
Student,
27
indexed_by<
28
ordered_non_unique<
29
// 使用 lambda 表达式提取姓名长度作为键
30
key_extractor<
31
identity<Student>, // 占位符，表示输入是 Student 对象本身
32
lambda<std::size_t(const Student&)> // lambda 表达式类型声明
33
>
34
>
35
>
36
> student_container;
37
38
student_container.insert({"Alice", 1001});
39
student_container.insert({"Bob", 1002});
40
student_container.insert({"Charlie", 1003});
41
student_container.insert({"David", 1004});
42
student_container.insert({"Eve", 1005}); // Eve 和 Bob 姓名长度相同
43
44
// 通过姓名长度 3 查找学生
45
auto& name_len_index = student_container.get<0>(); // 获取第一个索引 (姓名长度索引)
46
auto range = name_len_index.equal_range(3); // 查找姓名长度为 3 的范围
47
48
std::cout << "姓名长度为 3 的学生: " << std::endl;
49
for (auto it = range.first; it != range.second; ++it) {
50
std::cout << *it << std::endl;
51
// 输出：
52
// 姓名长度为 3 的学生:
53
// Name: Bob, ID: 1002
54
// Name: Eve, ID: 1005
55
}
56
57
return 0;
58
}
代码解析:
⚝ ordered_non_unique<key_extractor<identity<Student>, lambda<std::size_t(const Student&)>>>: 定义了一个 ordered_non_unique 索引，使用 lambda 表达式作为键提取器。
▮▮▮▮⚝ key_extractor<identity<Student>, lambda<std::size_t(const Student&)>>: 这是使用 lambda 表达式的关键结构。
▮▮▮▮▮▮▮▮⚝ identity<Student>: 占位符，表示 lambda 表达式的输入参数是容器中存储的对象本身，即 Student 对象。虽然这里使用了 identity，但它仅仅是作为占位符，实际的键提取逻辑由 lambda 表达式定义。
▮▮▮▮▮▮▮▮⚝ lambda<std::size_t(const Student&)>: lambda 表达式类型声明。
▮▮▮▮▮▮▮▮▮▮▮▮⚝ std::size_t: 指定 lambda 表达式返回的键的类型，即姓名长度是 std::size_t 类型。
▮▮▮▮▮▮▮▮▮▮▮▮⚝ (const Student&): 指定 lambda 表达式接受一个 const Student& 类型的参数。
▮▮▮▮▮▮▮▮⚝ 实际的 lambda 表达式定义在 indexed_by 声明之外，在运行时由 Boost.MultiIndex 内部处理。
更简洁的 lambda 表达式写法 (C++14 及以上):
在 C++14 及更高版本中，lambda 表达式可以自动推导返回类型，可以进一步简化代码：
1
#include <boost/multi_index_container.hpp>
2
#include <boost/multi_index/ordered_index.hpp>
3
#include <boost/multi_index/lambda.hpp>
4
#include <string>
5
#include <iostream>
6
7
using namespace boost::multi_index;
8
9
// ... Student 类定义 (同上) ...
10
11
int main() {
12
multi_index_container<
13
Student,
14
indexed_by<
15
ordered_non_unique<
16
key_extractor<
17
identity<Student>,
18
lambda<[](const Student& s){ return s.name.length(); }> // 更简洁的 lambda 表达式
19
>
20
>
21
>
22
> student_container;
23
24
// ... (插入和查找代码同上) ...
25
26
return 0;
27
}
在这个更简洁的版本中，我们直接在 lambda<> 模板参数中定义了 lambda 表达式 [](const Student& s){ return s.name.length(); }，编译器会自动推导出返回类型为 std::size_t。
适用场景:
⚝ 当键提取逻辑比较简单，可以直接用一行代码表达。
⚝ 需要在 indexed_by 声明中直接定义键提取逻辑，避免额外的函数定义。
⚝ 使用 C++11 或更高版本，可以充分利用 lambda 表达式的便利性。
总结:
lambda 表达式键提取器提供了极大的灵活性和简洁性。它允许我们以内联的方式定义键提取逻辑，使得代码更加紧凑和易于理解。尤其是在键提取逻辑比较简单的情况下，lambda 表达式是首选的键提取方式。
3.6 复合键 (Composite Keys) - composite_key
复合键 (Composite Keys) 允许我们使用多个键值组合成一个索引键。这在需要根据多个条件进行排序或查找时非常有用。Boost.MultiIndex 提供了 composite_key 来实现复合键。
示例：使用姓名和 ID 组合成复合键
假设我们需要根据学生的姓名和 ID 进行排序，首先按姓名排序，姓名相同的再按 ID 排序。我们可以使用 composite_key 将姓名和 ID 组合成一个复合键：
1
#include <boost/multi_index_container.hpp>
2
#include <boost/multi_index/ordered_index.hpp>
3
#include <boost/multi_index/member.hpp>
4
#include <boost/multi_index/composite_key.hpp> // 包含 composite_key.hpp
5
#include <string>
6
#include <iostream>
7
8
using namespace boost::multi_index;
9
10
class Student { // Student 类定义 (同上)
11
public:
12
std::string name;
13
int id;
14
15
Student(std::string n, int i) : name(n), id(i) {}
16
17
friend std::ostream& operator<<(std::ostream& os, const Student& student) {
18
os << "Name: " << student.name << ", ID: " << student.id;
19
return os;
20
}
21
};
22
23
24
int main() {
25
// 创建 multi_index_container，存储 Student 对象
26
multi_index_container<
27
Student,
28
indexed_by<
29
ordered_unique<
30
composite_key< // 定义复合键
31
Student,
32
member<Student, std::string, &Student::name>, // 第一个键：姓名
33
member<Student, int, &Student::id> // 第二个键：ID
34
>
35
>
36
>
37
> student_container;
38
39
student_container.insert({"Alice", 1002});
40
student_container.insert({"Bob", 1001});
41
student_container.insert({"Alice", 1001}); // 姓名和 ID 都相同，重复插入，ordered_unique 索引会忽略
42
student_container.insert({"Charlie", 1003});
43
student_container.insert({"Alice", 1003}); // 姓名相同，ID 不同，可以插入
44
45
// 遍历容器，观察排序结果
46
std::cout << "按姓名和 ID 排序的学生列表: " << std::endl;
47
for (const auto& student : student_container) {
48
std::cout << student << std::endl;
49
// 输出：
50
// 按姓名和 ID 排序的学生列表:
51
// Name: Alice, ID: 1001
52
// Name: Alice, ID: 1002
53
// Name: Alice, ID: 1003
54
// Name: Bob, ID: 1001
55
// Name: Charlie, ID: 1003
56
}
57
58
return 0;
59
}
代码解析:
⚝ ordered_unique<composite_key<Student, member<Student, std::string, &Student::name>, member<Student, int, &Student::id>>>: 定义了一个 ordered_unique 索引，使用 composite_key 作为键提取器。
▮▮▮▮⚝ composite_key<Student, ...>: 表示这是一个复合键，用于 Student 对象。
▮▮▮▮⚝ member<Student, std::string, &Student::name>: 第一个键，使用 name 成员变量。
▮▮▮▮⚝ member<Student, int, &Student::id>: 第二个键，使用 id 成员变量。
composite_key<Class, KeyExtractor1, KeyExtractor2, ..., KeyExtractorN> 的构成:
⚝ Class: 容器存储的对象的类类型。
⚝ KeyExtractor1, KeyExtractor2, ..., KeyExtractorN: 一系列键提取器，可以是 member, global_fun, const_mem_fun, lambda 等，用于提取复合键的各个组成部分。
复合键的排序规则:
复合键的排序规则是字典序 (lexicographical order)。即首先比较第一个键，如果第一个键相同，则比较第二个键，以此类推。在上面的例子中，首先按姓名排序，如果姓名相同，则按 ID 排序。
适用场景:
⚝ 需要根据多个条件进行排序或查找。
⚝ 需要实现多级排序，例如先按主键排序，再按次要键排序。
⚝ 需要组合多个成员变量或计算结果作为索引键。
总结:
composite_key 提供了强大的复合键功能，允许我们组合多个键值来定义索引。这使得 Multi-index 容器可以支持更复杂的排序和查找需求，满足各种实际应用场景。通过灵活组合不同的键提取器，我们可以构建出功能强大的多维度索引结构。
本章总结:
本章详细介绍了 Boost.MultiIndex 库中各种常用的键提取器 (Key Extractors)，包括：
⚝ 默认键提取器 (identity): 直接使用对象本身作为键，适用于简单类型或直接使用存储对象作为键的场景。
⚝ 成员指针键提取器 (member): 使用类成员变量作为键，适用于类对象，通过成员指针指定键的来源。
⚝ 全局函数键提取器 (global_fun): 使用全局函数计算键，适用于复杂的键计算逻辑或需要复用全局函数的场景。
⚝ 仿函数键提取器 (const_mem_fun, mem_fun): 使用类成员函数计算键，适用于键计算逻辑封装在类成员函数中的场景，优先使用 const_mem_fun。
⚝ lambda 表达式键提取器 (lambda): 使用 lambda 表达式内联定义键提取逻辑，适用于简单的键计算，代码简洁灵活。
⚝ 复合键 (composite_key): 组合多个键值形成复合键，适用于需要多条件排序或查找的场景。
理解和灵活运用这些键提取器是掌握 Boost.MultiIndex 的关键。选择合适的键提取器，可以有效地构建出满足各种需求的 Multi-index 容器，实现高效的数据管理和访问。在后续章节中，我们将继续深入探讨 Multi-index 的高级特性和实战应用。
END_OF_CHAPTER
4. chapter 4： 常用操作 (Common Operations)
4.1 插入元素 (Inserting Elements) - insert, emplace
在 Boost.MultiIndex 容器中插入元素是构建和维护数据的核心操作之一。multi_index_container 提供了与标准库容器类似的 insert 和 emplace 方法，用于向容器中添加新的元素。由于 multi_index_container 拥有多个索引，插入操作需要确保新元素在所有索引中都正确就位。
insert 操作
insert 函数用于将已构造的对象或对象的拷贝插入到 multi_index_container 中。它有多种重载形式，最常用的是接受一个要插入的值作为参数的版本。
1
#include <boost/multi_index_container.hpp>
2
#include <boost/multi_index/ordered_index.hpp>
3
#include <boost/multi_index/identity.hpp>
4
#include <string>
5
#include <iostream>
6
7
using namespace boost::multi_index;
8
9
// 定义存储元素的结构体
10
struct Person {
11
int id;
12
std::string name;
13
14
Person(int id, const std::string& name) : id(id), name(name) {}
15
16
friend std::ostream& operator<<(std::ostream& os, const Person& person) {
17
os << "ID: " << person.id << ", Name: " << person.name;
18
return os;
19
}
20
};
21
22
// 定义 multi_index_container
23
typedef multi_index_container<
24
Person,
25
indexed_by<
26
ordered_unique<identity<Person>> // 主索引，按 Person 对象自身排序 (假设 Person 定义了 operator<)
27
>
28
> PersonContainer;
29
30
int main() {
31
PersonContainer persons;
32
33
// 使用 insert 插入元素
34
Person person1(1, "Alice");
35
persons.insert(person1); // 插入 person1 的拷贝
36
37
Person person2(2, "Bob");
38
persons.insert(person2); // 插入 person2 的拷贝
39
40
// 遍历容器并打印元素
41
for (const auto& person : persons) {
42
std::cout << person << std::endl;
43
}
44
45
return 0;
46
}
在这个例子中，我们创建了一个 PersonContainer，它使用 ordered_unique 索引，以 Person 对象自身作为键。insert(person1) 和 insert(person2) 将 person1 和 person2 的拷贝插入到容器中。由于我们使用了 ordered_unique 索引，如果尝试插入具有相同键（在本例中，如果 Person 的比较操作符基于某些唯一属性，例如 id）的元素，插入操作可能会失败，或者根据索引类型的特性，旧元素可能被保留，新元素被忽略。
emplace 操作
emplace 函数提供了直接在容器内部构造元素的能力，避免了创建临时对象和拷贝操作，通常更高效，尤其是在处理构造开销较大的对象时。emplace 接受构造函数参数，并在容器的内部直接使用这些参数构造对象。
1
#include <boost/multi_index_container.hpp>
2
#include <boost/multi_index/ordered_index.hpp>
3
#include <boost/multi_index/identity.hpp>
4
#include <string>
5
#include <iostream>
6
7
using namespace boost::multi_index;
8
9
// 定义存储元素的结构体 (与上例相同)
10
struct Person {
11
int id;
12
std::string name;
13
14
Person(int id, const std::string& name) : id(id), name(name) {}
15
16
friend std::ostream& operator<<(std::ostream& os, const Person& person) {
17
os << "ID: " << person.id << ", Name: " << person.name;
18
return os;
19
}
20
};
21
22
// 定义 multi_index_container (与上例相同)
23
typedef multi_index_container<
24
Person,
25
indexed_by<
26
ordered_unique<identity<Person>>
27
>
28
> PersonContainer;
29
30
int main() {
31
PersonContainer persons;
32
33
// 使用 emplace 插入元素
34
persons.emplace(1, "Alice"); // 直接在容器内构造 Person 对象
35
persons.emplace(2, "Bob"); // 直接在容器内构造 Person 对象
36
37
// 遍历容器并打印元素
38
for (const auto& person : persons) {
39
std::cout << person << std::endl;
40
}
41
42
return 0;
43
}
在这个例子中，persons.emplace(1, "Alice") 和 persons.emplace(2, "Bob") 直接在 PersonContainer 内部构造 Person 对象，避免了像 insert 那样先创建 Person 对象再拷贝的过程。这在性能敏感的应用中尤其重要。
返回值
insert 和 emplace 的返回值取决于所使用的索引类型。对于 unique 索引（如 ordered_unique, hashed_unique），如果插入成功，它们返回一个迭代器，指向新插入的元素，以及一个 bool 值 true。如果插入失败（例如，因为键已存在于 unique 索引中），它们返回一个迭代器，指向阻止插入的现有元素，以及一个 bool 值 false。对于 non_unique 索引（如 ordered_non_unique, hashed_non_unique, sequenced, random_access），插入总是成功，它们只返回一个迭代器，指向新插入的元素。
插入到特定索引
默认情况下，insert 和 emplace 操作会影响 multi_index_container 中的所有索引。你可以通过使用特定索引的迭代器作为插入位置的提示 (hint)，来优化插入性能，尤其是在 ordered_index 中。但这通常是高级用法，在大多数情况下，简单的 insert 和 emplace 就足够了。
总结来说，insert 和 emplace 是向 Boost.MultiIndex 容器添加元素的基本方法。emplace 通常更高效，因为它避免了不必要的拷贝。选择使用哪个函数取决于具体的需求和性能考量。理解它们的返回值和在不同索引类型下的行为对于正确使用 Boost.MultiIndex 至关重要。
4.2 查找元素 (Finding Elements) - find, count, lower_bound, upper_bound, equal_range
Boost.MultiIndex 容器的强大之处在于它可以通过多个索引快速查找元素。针对不同的索引类型，multi_index_container 提供了多种查找方法，包括 find, count, lower_bound, upper_bound, 和 equal_range。这些方法允许你根据不同的键高效地检索数据。
find 操作
find 函数用于查找容器中与给定键匹配的元素。它返回一个迭代器，指向找到的第一个匹配元素。如果未找到匹配的元素，则返回指向容器 end() 的迭代器。find 操作可以应用于任何索引，但其效率取决于索引的类型。对于有序索引和哈希索引，find 通常能提供对数时间或常数时间的平均复杂度查找性能。
1
#include <boost/multi_index_container.hpp>
2
#include <boost/multi_index/ordered_index.hpp>
3
#include <boost/multi_index/member.hpp>
4
#include <string>
5
#include <iostream>
6
7
using namespace boost::multi_index;
8
9
struct Person {
10
int id;
11
std::string name;
12
13
Person(int id, const std::string& name) : id(id), name(name) {}
14
15
friend std::ostream& operator<<(std::ostream& os, const Person& person) {
16
os << "ID: " << person.id << ", Name: " << person.name;
17
return os;
18
}
19
};
20
21
// 定义 multi_index_container，使用 id 作为有序索引
22
typedef multi_index_container<
23
Person,
24
indexed_by<
25
ordered_unique<member<Person, int, &Person::id>> // 按 id 排序的唯一索引
26
>
27
> PersonContainer;
28
29
int main() {
30
PersonContainer persons;
31
persons.emplace(1, "Alice");
32
persons.emplace(2, "Bob");
33
persons.emplace(3, "Charlie");
34
35
// 获取索引视图 (index view)，索引 #0 是按 id 排序的索引
36
auto& id_index = persons.get<0>();
37
38
// 使用 find 通过 id 查找 Person
39
auto it = id_index.find(2); // 查找 id 为 2 的 Person
40
41
if (it != id_index.end()) {
42
std::cout << "找到 Person: " << *it << std::endl; // 输出 "找到 Person: ID: 2, Name: Bob"
43
} else {
44
std::cout << "未找到 Person" << std::endl;
45
}
46
47
it = id_index.find(4); // 查找 id 为 4 的 Person (不存在)
48
if (it == id_index.end()) {
49
std::cout << "未找到 Person (id=4)" << std::endl; // 输出 "未找到 Person (id=4)"
50
}
51
52
return 0;
53
}
在这个例子中，我们通过 persons.get<0>() 获取了第一个索引（按 id 排序的 ordered_unique 索引）的视图 id_index。然后，我们使用 id_index.find(2) 查找 id 为 2 的 Person 对象。
count 操作
count 函数返回容器中与给定键匹配的元素数量。对于 unique 索引，count 的返回值只能是 0 或 1。对于 non_unique 索引，count 可以返回大于 1 的值。
1
#include <boost/multi_index_container.hpp>
2
#include <boost/multi_index/ordered_index.hpp>
3
#include <boost/multi_index/member.hpp>
4
#include <string>
5
#include <iostream>
6
7
using namespace boost::multi_index;
8
9
struct Person {
10
int age;
11
std::string name;
12
13
Person(int age, const std::string& name) : age(age), name(name) {}
14
15
friend std::ostream& operator<<(std::ostream& os, const Person& person) {
16
os << "Age: " << person.age << ", Name: " << person.name;
17
return os;
18
}
19
};
20
21
// 定义 multi_index_container，使用 age 作为非唯一有序索引
22
typedef multi_index_container<
23
Person,
24
indexed_by<
25
ordered_non_unique<member<Person, int, &Person::age>> // 按 age 排序的非唯一索引
26
>
27
> PersonContainer;
28
29
int main() {
30
PersonContainer persons;
31
persons.emplace(25, "Alice");
32
persons.emplace(30, "Bob");
33
persons.emplace(25, "Charlie"); // 与 Alice 年龄相同
34
35
// 获取索引视图 (index view)，索引 #0 是按 age 排序的索引
36
auto& age_index = persons.get<0>();
37
38
// 使用 count 统计 age 为 25 的 Person 数量
39
size_t count = age_index.count(25);
40
std::cout << "年龄为 25 的人数: " << count << std::endl; // 输出 "年龄为 25 的人数: 2"
41
42
count = age_index.count(40);
43
std::cout << "年龄为 40 的人数: " << count << std::endl; // 输出 "年龄为 40 的人数: 0"
44
45
return 0;
46
}
在这个例子中，我们使用了 ordered_non_unique 索引，允许年龄重复。age_index.count(25) 返回年龄为 25 的 Person 对象数量，结果为 2。
lower_bound 和 upper_bound 操作
lower_bound 和 upper_bound 函数用于在有序索引中执行范围查找。lower_bound(key) 返回一个迭代器，指向第一个键值不小于给定键 key 的元素。upper_bound(key) 返回一个迭代器，指向第一个键值大于给定键 key 的元素。这两个函数通常一起使用来确定一个键值范围。
1
#include <boost/multi_index_container.hpp>
2
#include <boost/multi_index/ordered_index.hpp>
3
#include <boost/multi_index/member.hpp>
4
#include <string>
5
#include <iostream>
6
7
using namespace boost::multi_index;
8
9
struct Person {
10
int age;
11
std::string name;
12
13
Person(int age, const std::string& name) : age(age), name(name) {}
14
15
friend std::ostream& operator<<(std::ostream& os, const Person& person) {
16
os << "Age: " << person.age << ", Name: " << person.name;
17
return os;
18
}
19
};
20
21
// 定义 multi_index_container，使用 age 作为有序索引
22
typedef multi_index_container<
23
Person,
24
indexed_by<
25
ordered_non_unique<member<Person, int, &Person::age>> // 按 age 排序的非唯一索引
26
>
27
> PersonContainer;
28
29
int main() {
30
PersonContainer persons;
31
persons.emplace(20, "David");
32
persons.emplace(25, "Alice");
33
persons.emplace(25, "Charlie");
34
persons.emplace(30, "Bob");
35
persons.emplace(35, "Eve");
36
37
// 获取索引视图 (index view)，索引 #0 是按 age 排序的索引
38
auto& age_index = persons.get<0>();
39
40
// 查找年龄在 [25, 30) 范围内的 Person
41
auto lower_it = age_index.lower_bound(25); // 第一个 age >= 25 的元素
42
auto upper_it = age_index.upper_bound(30); // 第一个 age > 30 的元素
43
44
std::cout << "年龄在 [25, 30) 范围内的 Person:" << std::endl;
45
for (auto it = lower_it; it != upper_it; ++it) {
46
std::cout << *it << std::endl;
47
}
48
// 输出:
49
// 年龄在 [25, 30) 范围内的 Person:
50
// Age: 25, Name: Alice
51
// Age: 25, Name: Charlie
52
// Age: 30, Name: Bob (不包含，因为 upper_bound 指向第一个 age > 30 的元素)
53
54
return 0;
55
}
在这个例子中，age_index.lower_bound(25) 返回指向第一个年龄不小于 25 的元素的迭代器，age_index.upper_bound(30) 返回指向第一个年龄大于 30 的元素的迭代器。循环遍历 [lower_it, upper_it) 范围内的元素，即可得到年龄在 [25, 30) 范围内的所有 Person 对象。
equal_range 操作
equal_range(key) 函数是 lower_bound 和 upper_bound 的组合。它返回一个 std::pair，其中 first 成员是 lower_bound(key) 返回的迭代器，second 成员是 upper_bound(key) 返回的迭代器。equal_range 用于一次性获取与给定键值相等的所有元素的范围。
1
#include <boost/multi_index_container.hpp>
2
#include <boost/multi_index/ordered_index.hpp>
3
#include <boost/multi_index/member.hpp>
4
#include <string>
5
#include <iostream>
6
7
using namespace boost::multi_index;
8
9
struct Person {
10
int age;
11
std::string name;
12
13
Person(int age, const std::string& name) : age(age), name(name) {}
14
15
friend std::ostream& operator<<(std::ostream& os, const Person& person) {
16
os << "Age: " << person.age << ", Name: " << person.name;
17
return os;
18
}
19
};
20
21
// 定义 multi_index_container (与上例相同)
22
typedef multi_index_container<
23
Person,
24
indexed_by<
25
ordered_non_unique<member<Person, int, &Person::age>>
26
>
27
> PersonContainer;
28
29
int main() {
30
PersonContainer persons;
31
persons.emplace(25, "Alice");
32
persons.emplace(30, "Bob");
33
persons.emplace(25, "Charlie");
34
35
// 获取索引视图 (index view)，索引 #0 是按 age 排序的索引
36
auto& age_index = persons.get<0>();
37
38
// 使用 equal_range 查找 age 为 25 的 Person 范围
39
auto range = age_index.equal_range(25);
40
41
std::cout << "年龄为 25 的 Person:" << std::endl;
42
for (auto it = range.first; it != range.second; ++it) {
43
std::cout << *it << std::endl;
44
}
45
// 输出:
46
// 年龄为 25 的 Person:
47
// Age: 25, Name: Alice
48
// Age: 25, Name: Charlie
49
50
return 0;
51
}
在这个例子中，age_index.equal_range(25) 返回一个 std::pair，其 first 迭代器指向第一个年龄为 25 的元素，second 迭代器指向第一个年龄大于 25 的元素。循环遍历这个范围，即可得到所有年龄为 25 的 Person 对象。
在不同索引上查找
重要的是要记住，这些查找操作是基于特定的索引执行的。要使用不同的键进行查找，你需要获取相应的索引视图，然后在该视图上调用查找函数。例如，如果你的 multi_index_container 除了按 id 排序的索引外，还有按 name 排序的索引，你可以通过 persons.get<1>().find("Alice") 在按 name 排序的索引上查找名为 "Alice" 的 Person。
总结来说，Boost.MultiIndex 提供了丰富的查找功能，允许你根据不同的键和索引类型高效地检索容器中的元素。find, count, lower_bound, upper_bound, 和 equal_range 提供了灵活的查找策略，满足各种数据检索需求。理解这些操作的用法和适用场景，可以充分利用 Boost.MultiIndex 的多索引优势。
4.3 范围查询 (Range Queries)
范围查询是指查找容器中键值在特定范围内的所有元素。Boost.MultiIndex 容器通过有序索引（ordered_index）和哈希索引（hashed_index）支持高效的范围查询。对于有序索引，可以使用 lower_bound 和 upper_bound 或 equal_range 来进行范围查询，如前一节所述。对于哈希索引，虽然不能直接进行基于顺序的范围查询，但可以进行基于键值相等的范围查询，即查找所有与给定键值相等的元素。
有序索引的范围查询
如 4.2 节中 lower_bound, upper_bound, 和 equal_range 的例子所示，有序索引天然支持范围查询。你可以使用 lower_bound 找到范围的下界，upper_bound 找到范围的上界，然后遍历这两个迭代器之间的元素。equal_range 特别适用于查找键值等于某个特定值的范围。
1
#include <boost/multi_index_container.hpp>
2
#include <boost/multi_index/ordered_index.hpp>
3
#include <boost/multi_index/member.hpp>
4
#include <string>
5
#include <iostream>
6
7
using namespace boost::multi_index;
8
9
struct Product {
10
double price;
11
std::string name;
12
13
Product(double price, const std::string& name) : price(price), name(name) {}
14
15
friend std::ostream& operator<<(std::ostream& os, const Product& product) {
16
os << "Price: " << product.price << ", Name: " << product.name;
17
return os;
18
}
19
};
20
21
// 定义 multi_index_container，使用 price 作为有序索引
22
typedef multi_index_container<
23
Product,
24
indexed_by<
25
ordered_non_unique<member<Product, double, &Product::price>> // 按 price 排序的非唯一索引
26
>
27
> ProductContainer;
28
29
int main() {
30
ProductContainer products;
31
products.emplace(19.99, "Laptop");
32
products.emplace(9.99, "Mouse");
33
products.emplace(29.99, "Keyboard");
34
products.emplace(19.99, "Monitor");
35
products.emplace(49.99, "Printer");
36
37
// 获取索引视图 (index view)，索引 #0 是按 price 排序的索引
38
auto& price_index = products.get<0>();
39
40
// 查找价格在 [10.00, 30.00] 范围内的产品
41
auto lower_it = price_index.lower_bound(10.00); // 第一个 price >= 10.00 的元素
42
auto upper_it = price_index.upper_bound(30.00); // 第一个 price > 30.00 的元素
43
44
std::cout << "价格在 [10.00, 30.00] 范围内的产品:" << std::endl;
45
for (auto it = lower_it; it != upper_it; ++it) {
46
std::cout << *it << std::endl;
47
}
48
// 输出:
49
// 价格在 [10.00, 30.00] 范围内的产品:
50
// Price: 19.99, Name: Laptop
51
// Price: 29.99, Name: Keyboard
52
// Price: 19.99, Name: Monitor
53
// Price: 9.99, Name: Mouse (不包含，因为 lower_bound 是 >= 10.00)
54
55
return 0;
56
}
在这个例子中，我们使用 price_index.lower_bound(10.00) 和 price_index.upper_bound(30.00) 找到了价格在 [10.00, 30.00] 范围内的产品。注意 lower_bound 包含下界 (>= 10.00)，而 upper_bound 不包含上界 (> 30.00)。如果要包含上界 (<= 30.00)，你需要使用略大于上界的值作为 upper_bound 的参数，或者手动调整迭代器范围。例如，在本例中，如果想包含价格为 30.00 的产品（如果存在），则需要使用 price_index.upper_bound(30.01) 或类似的方法，并仔细检查迭代器是否超出范围。更精确的做法是使用 std::distance 来计算范围，并确保不超过容器的 end()。
哈希索引的范围查询
哈希索引主要用于快速查找特定键值的元素，而不是范围查询。但是，哈希索引可以有效地执行基于键值相等的范围查询，即查找所有与给定键值相等的元素。你可以使用 equal_range 或手动结合 lower_bound 和 upper_bound (即使对于哈希索引，这些函数仍然存在，但它们的行为是基于键值相等性，而不是顺序)。
1
#include <boost/multi_index_container.hpp>
2
#include <boost/multi_index/hashed_index.hpp>
3
#include <boost/multi_index/member.hpp>
4
#include <string>
5
#include <iostream>
6
7
using namespace boost::multi_index;
8
9
struct Book {
10
std::string isbn;
11
std::string title;
12
13
Book(const std::string& isbn, const std::string& title) : isbn(isbn), title(title) {}
14
15
friend std::ostream& operator<<(std::ostream& os, const Book& book) {
16
os << "ISBN: " << book.isbn << ", Title: " << book.title;
17
return os;
18
}
19
};
20
21
// 定义 multi_index_container，使用 isbn 作为哈希索引
22
typedef multi_index_container<
23
Book,
24
indexed_by<
25
hashed_unique<member<Book, std::string, &Book::isbn>> // 按 isbn 哈希的唯一索引
26
>
27
> BookContainer;
28
29
int main() {
30
BookContainer books;
31
books.emplace("978-0321765723", "Effective C++");
32
books.emplace("978-0201633648", "Design Patterns");
33
books.emplace("978-0321992668", "More Effective C++");
34
books.emplace("978-0321765723", "Effective C++ (Duplicate ISBN)"); // ISBN 重复，hashed_unique 会阻止插入
35
36
// 获取索引视图 (index view)，索引 #0 是按 isbn 哈希的索引
37
auto& isbn_index = books.get<0>();
38
39
// 查找 ISBN 为 "978-0321765723" 的书籍
40
auto range = isbn_index.equal_range("978-0321765723");
41
42
std::cout << "ISBN 为 '978-0321765723' 的书籍:" << std::endl;
43
for (auto it = range.first; it != range.second; ++it) {
44
std::cout << *it << std::endl;
45
}
46
// 输出:
47
// ISBN 为 '978-0321765723' 的书籍:
48
// ISBN: 978-0321765723, Title: Effective C++
49
50
return 0;
51
}
在这个例子中，我们使用 isbn_index.equal_range("978-0321765723") 在哈希索引上查找 ISBN 为 "978-0321765723" 的书籍。由于 hashed_unique 索引保证键的唯一性，equal_range 返回的范围要么包含一个元素，要么为空。对于 hashed_non_unique 索引，equal_range 可以返回包含多个元素的范围，如果存在多个具有相同哈希键的元素。
序列索引和随机访问索引
序列索引 (sequenced_index) 和随机访问索引 (random_access_index) 主要用于按插入顺序或位置访问元素，它们不直接支持基于键值的范围查询。对于 sequenced_index，你可以遍历整个序列来查找特定范围的元素（如果需要基于元素属性的范围查询，而不是位置）。对于 random_access_index，你可以通过索引位置访问元素，但范围查询的概念更多地与有序或哈希索引相关。
总结来说，Boost.MultiIndex 通过有序索引和哈希索引提供了强大的范围查询能力。有序索引支持基于键值顺序的范围查询，而哈希索引支持基于键值相等的范围查询。选择合适的索引类型取决于你的应用场景和查询需求。理解不同索引类型的范围查询特性，可以更有效地利用 Boost.MultiIndex 进行数据检索。
4.4 修改元素 (Modifying Elements) - modify, replace
在 Boost.MultiIndex 容器中修改元素是一个相对复杂的操作，因为修改元素可能会影响到所有索引的排序和结构。multi_index_container 提供了 modify 和 replace 函数来安全地修改元素，同时维护索引的完整性。
modify 操作
modify 函数是修改 multi_index_container 中元素的主要方法。它允许你修改元素的非键值成员，或者在某些情况下，修改键值成员，同时确保容器的所有索引都得到正确更新。modify 操作通常需要一个迭代器指向要修改的元素，以及一个修改器函数或函数对象，该函数接受对元素的非常量引用，并在原地修改元素。
1
#include <boost/multi_index_container.hpp>
2
#include <boost/multi_index/ordered_index.hpp>
3
#include <boost/multi_index/member.hpp>
4
#include <string>
5
#include <iostream>
6
7
using namespace boost::multi_index;
8
9
struct Person {
10
int id; // 键值
11
std::string name; // 非键值
12
int age; // 非键值
13
14
Person(int id, const std::string& name, int age) : id(id), name(name), age(age) {}
15
16
friend std::ostream& operator<<(std::ostream& os, const Person& person) {
17
os << "ID: " << person.id << ", Name: " << person.name << ", Age: " << person.age;
18
return os;
19
}
20
};
21
22
// 定义 multi_index_container，使用 id 作为有序唯一索引
23
typedef multi_index_container<
24
Person,
25
indexed_by<
26
ordered_unique<member<Person, int, &Person::id>> // 按 id 排序的唯一索引
27
>
28
> PersonContainer;
29
30
int main() {
31
PersonContainer persons;
32
persons.emplace(1, "Alice", 25);
33
persons.emplace(2, "Bob", 30);
34
35
// 获取索引视图 (index view)，索引 #0 是按 id 排序的索引
36
auto& id_index = persons.get<0>();
37
38
// 查找 id 为 1 的 Person
39
auto it = id_index.find(1);
40
if (it != id_index.end()) {
41
// 使用 modify 修改 name 和 age
42
id_index.modify(it, [](Person& p) {
43
p.name = "Alice Smith";
44
p.age = 26;
45
});
46
std::cout << "修改后的 Person: " << *it << std::endl; // 输出 "修改后的 Person: ID: 1, Name: Alice Smith, Age: 26"
47
}
48
49
return 0;
50
}
在这个例子中，我们使用 id_index.modify(it, ...) 修改了 id 为 1 的 Person 对象的 name 和 age 成员。修改器函数是一个 lambda 表达式 [](Person& p) { ... }，它接受对 Person 对象的非常量引用，并在原地修改对象的 name 和 age 成员。
修改键值
修改键值成员需要特别小心，因为这可能会改变元素在索引中的位置。对于 unique 索引，如果修改后的键值与容器中已存在的键值冲突，modify 操作可能会失败。modify 函数的返回值是一个 bool 值，指示修改是否成功。如果修改成功，返回 true；如果修改失败（例如，因为修改后的键值与 unique 索引中的现有键值冲突），返回 false。
1
#include <boost/multi_index_container.hpp>
2
#include <boost/multi_index/ordered_index.hpp>
3
#include <boost/multi_index/member.hpp>
4
#include <string>
5
#include <iostream>
6
7
using namespace boost::multi_index;
8
9
struct Person {
10
int id; // 键值
11
std::string name;
12
int age;
13
14
Person(int id, const std::string& name, int age) : id(id), name(name), age(age) {}
15
16
friend std::ostream& operator<<(std::ostream& os, const Person& person) {
17
os << "ID: " << person.id << ", Name: " << person.name << ", Age: " << person.age;
18
return os;
19
}
20
};
21
22
// 定义 multi_index_container，使用 id 作为有序唯一索引
23
typedef multi_index_container<
24
Person,
25
indexed_by<
26
ordered_unique<member<Person, int, &Person::id>> // 按 id 排序的唯一索引
27
>
28
> PersonContainer;
29
30
int main() {
31
PersonContainer persons;
32
persons.emplace(1, "Alice", 25);
33
persons.emplace(2, "Bob", 30);
34
35
// 获取索引视图 (index view)，索引 #0 是按 id 排序的索引
36
auto& id_index = persons.get<0>();
37
38
// 查找 id 为 1 的 Person
39
auto it = id_index.find(1);
40
if (it != id_index.end()) {
41
// 尝试修改 id 为 2 (与已存在的元素冲突)
42
bool modified = id_index.modify(it, [](Person& p) {
43
p.id = 2; // 尝试修改键值
44
});
45
if (modified) {
46
std::cout << "成功修改 Person: " << *it << std::endl;
47
} else {
48
std::cout << "修改失败，键值冲突" << std::endl; // 输出 "修改失败，键值冲突"
49
}
50
}
51
52
return 0;
53
}
在这个例子中，我们尝试将 id 为 1 的 Person 对象的 id 修改为 2。由于 id 为 2 的 Person 对象已经存在于容器中，且索引是 ordered_unique，modify 操作失败，返回 false。
replace 操作
replace 函数是另一种修改元素的方法。它用一个新构造的对象替换容器中的现有元素。replace 操作通常需要一个迭代器指向要替换的元素，以及一个新对象，用于替换旧元素。与 modify 类似，replace 也需要考虑索引的唯一性约束。
1
#include <boost/multi_index_container.hpp>
2
#include <boost/multi_index/ordered_index.hpp>
3
#include <boost/multi_index/member.hpp>
4
#include <string>
5
#include <iostream>
6
7
using namespace boost::multi_index;
8
9
struct Person {
10
int id; // 键值
11
std::string name;
12
int age;
13
14
Person(int id, const std::string& name, int age) : id(id), name(name), age(age) {}
15
16
friend std::ostream& operator<<(std::ostream& os, const Person& person) {
17
os << "ID: " << person.id << ", Name: " << person.name << ", Age: " << person.age;
18
return os;
19
}
20
};
21
22
// 定义 multi_index_container (与上例相同)
23
typedef multi_index_container<
24
Person,
25
indexed_by<
26
ordered_unique<member<Person, int, &Person::id>>
27
>
28
> PersonContainer;
29
30
int main() {
31
PersonContainer persons;
32
persons.emplace(1, "Alice", 25);
33
persons.emplace(2, "Bob", 30);
34
35
// 获取索引视图 (index view)，索引 #0 是按 id 排序的索引
36
auto& id_index = persons.get<0>();
37
38
// 查找 id 为 1 的 Person
39
auto it = id_index.find(1);
40
if (it != id_index.end()) {
41
// 使用 replace 替换为新的 Person 对象
42
Person new_person(1, "Alice Updated", 27); // id 保持不变，name 和 age 更新
43
id_index.replace(it, new_person);
44
std::cout << "替换后的 Person: " << *it << std::endl; // 输出 "替换后的 Person: ID: 1, Name: Alice Updated, Age: 27"
45
}
46
47
return 0;
48
}
在这个例子中，我们使用 id_index.replace(it, new_person) 将 id 为 1 的 Person 对象替换为一个新的 Person 对象 new_person。replace 操作会用 new_person 替换迭代器 it 指向的元素。
注意事项
⚝ 迭代器失效: 在 modify 和 replace 操作期间，指向被修改元素的迭代器通常保持有效，但其他迭代器可能会失效，尤其是在 sequenced_index 和 random_access_index 中。建议在修改操作后重新获取迭代器，如果需要继续遍历容器。
⚝ 异常安全: modify 和 replace 操作需要保证异常安全。如果修改器函数或对象的执行过程中抛出异常，容器的状态应保持一致性。
⚝ 性能考量: 修改操作可能比插入和删除操作更昂贵，因为它可能涉及到多个索引的更新。在性能敏感的应用中，应谨慎使用修改操作，并考虑是否可以通过删除旧元素并插入新元素来替代。
总结来说，modify 和 replace 是 Boost.MultiIndex 提供的用于修改容器中元素的关键操作。modify 允许原地修改元素成员，而 replace 用新对象替换现有元素。在修改键值成员时，需要特别注意索引的唯一性约束和操作的返回值。理解这些操作的用法和限制，可以安全有效地修改 Boost.MultiIndex 容器中的数据。
4.5 删除元素 (Erasing Elements) - erase, clear
从 Boost.MultiIndex 容器中删除元素是管理数据生命周期的重要操作。multi_index_container 提供了 erase 和 clear 函数，用于删除容器中的元素。erase 函数可以删除单个元素或一个范围内的元素，而 clear 函数删除容器中的所有元素。
erase 操作
erase 函数用于从 multi_index_container 中删除一个或多个元素。它有多种重载形式：
⚝ 删除单个元素: 接受一个迭代器作为参数，删除迭代器指向的元素。
⚝ 删除一个范围内的元素: 接受一对迭代器 [first, last) 作为参数，删除该范围内的所有元素。
⚝ 按键值删除 (仅限有序索引和哈希索引): 接受一个键值作为参数，删除所有与该键值匹配的元素（对于 unique 索引，最多删除一个元素；对于 non_unique 索引，可能删除多个元素）。
删除单个元素 (迭代器)
1
#include <boost/multi_index_container.hpp>
2
#include <boost/multi_index/ordered_index.hpp>
3
#include <boost/multi_index/member.hpp>
4
#include <string>
5
#include <iostream>
6
7
using namespace boost::multi_index;
8
9
struct Person {
10
int id;
11
std::string name;
12
13
Person(int id, const std::string& name) : id(id), name(name) {}
14
15
friend std::ostream& operator<<(std::ostream& os, const Person& person) {
16
os << "ID: " << person.id << ", Name: " << person.name;
17
return os;
18
}
19
};
20
21
// 定义 multi_index_container，使用 id 作为有序索引
22
typedef multi_index_container<
23
Person,
24
indexed_by<
25
ordered_unique<member<Person, int, &Person::id>> // 按 id 排序的唯一索引
26
>
27
> PersonContainer;
28
29
int main() {
30
PersonContainer persons;
31
persons.emplace(1, "Alice");
32
persons.emplace(2, "Bob");
33
persons.emplace(3, "Charlie");
34
35
// 获取索引视图 (index view)，索引 #0 是按 id 排序的索引
36
auto& id_index = persons.get<0>();
37
38
// 查找 id 为 2 的 Person
39
auto it = id_index.find(2);
40
if (it != id_index.end()) {
41
// 使用 erase 删除找到的元素
42
id_index.erase(it);
43
std::cout << "删除 id 为 2 的 Person 后，容器大小: " << persons.size() << std::endl; // 输出 "删除 id 为 2 的 Person 后，容器大小: 2"
44
}
45
46
// 遍历容器并打印剩余元素
47
for (const auto& person : persons) {
48
std::cout << person << std::endl;
49
}
50
// 输出:
51
// ID: 1, Name: Alice
52
// ID: 3, Name: Charlie
53
54
return 0;
55
}
在这个例子中，我们使用 id_index.erase(it) 删除了迭代器 it 指向的 Person 对象（即 id 为 2 的 Person）。
删除一个范围内的元素 (迭代器范围)
1
#include <boost/multi_index_container.hpp>
2
#include <boost/multi_index/ordered_index.hpp>
3
#include <boost/multi_index/member.hpp>
4
#include <string>
5
#include <iostream>
6
#include <algorithm>
7
8
using namespace boost::multi_index;
9
10
struct Person {
11
int age;
12
std::string name;
13
14
Person(int age, const std::string& name) : age(age), name(name) {}
15
16
friend std::ostream& operator<<(std::ostream& os, const Person& person) {
17
os << "Age: " << person.age << ", Name: " << person.name;
18
return os;
19
}
20
};
21
22
// 定义 multi_index_container，使用 age 作为有序索引
23
typedef multi_index_container<
24
Person,
25
indexed_by<
26
ordered_non_unique<member<Person, int, &Person::age>> // 按 age 排序的非唯一索引
27
>
28
> PersonContainer;
29
30
int main() {
31
PersonContainer persons;
32
persons.emplace(20, "David");
33
persons.emplace(25, "Alice");
34
persons.emplace(25, "Charlie");
35
persons.emplace(30, "Bob");
36
persons.emplace(35, "Eve");
37
38
// 获取索引视图 (index view)，索引 #0 是按 age 排序的索引
39
auto& age_index = persons.get<0>();
40
41
// 查找年龄在 [25, 30) 范围内的 Person
42
auto lower_it = age_index.lower_bound(25);
43
auto upper_it = age_index.upper_bound(30);
44
45
// 使用 erase 删除 [lower_it, upper_it) 范围内的元素
46
age_index.erase(lower_it, upper_it);
47
std::cout << "删除年龄在 [25, 30) 范围内的 Person 后，容器大小: " << persons.size() << std::endl; // 输出 "删除年龄在 [25, 30) 范围内的 Person 后，容器大小: 3"
48
49
// 遍历容器并打印剩余元素
50
for (const auto& person : persons) {
51
std::cout << person << std::endl;
52
}
53
// 输出:
54
// Age: 20, Name: David
55
// Age: 30, Name: Bob (不包含，因为范围是 [25, 30) )
56
// Age: 35, Name: Eve
57
58
return 0;
59
}
在这个例子中，我们使用 age_index.erase(lower_it, upper_it) 删除了年龄在 [25, 30) 范围内的所有 Person 对象。
按键值删除 (有序索引和哈希索引)
1
#include <boost/multi_index_container.hpp>
2
#include <boost/multi_index/ordered_index.hpp>
3
#include <boost/multi_index/member.hpp>
4
#include <string>
5
#include <iostream>
6
7
using namespace boost::multi_index;
8
9
struct Person {
10
int age;
11
std::string name;
12
13
Person(int age, const std::string& name) : age(age), name(name) {}
14
15
friend std::ostream& operator<<(std::ostream& os, const Person& person) {
16
os << "Age: " << person.age << ", Name: " << person.name;
17
return os;
18
}
19
};
20
21
// 定义 multi_index_container，使用 age 作为非唯一有序索引
22
typedef multi_index_container<
23
Person,
24
indexed_by<
25
ordered_non_unique<member<Person, int, &Person::age>> // 按 age 排序的非唯一索引
26
>
27
> PersonContainer;
28
29
int main() {
30
PersonContainer persons;
31
persons.emplace(25, "Alice");
32
persons.emplace(30, "Bob");
33
persons.emplace(25, "Charlie");
34
35
// 获取索引视图 (index view)，索引 #0 是按 age 排序的索引
36
auto& age_index = persons.get<0>();
37
38
// 使用 erase 按键值删除 age 为 25 的 Person
39
size_t erased_count = age_index.erase(25);
40
std::cout << "删除了 " << erased_count << " 个年龄为 25 的 Person，容器大小: " << persons.size() << std::endl; // 输出 "删除了 2 个年龄为 25 的 Person，容器大小: 1"
41
42
// 遍历容器并打印剩余元素
43
for (const auto& person : persons) {
44
std::cout << person << std::endl;
45
}
46
// 输出:
47
// Age: 30, Name: Bob
48
49
return 0;
50
}
在这个例子中，age_index.erase(25) 删除了所有年龄为 25 的 Person 对象，返回值为删除的元素数量。
clear 操作
clear 函数用于删除 multi_index_container 中的所有元素，使容器变为空。
1
#include <boost/multi_index_container.hpp>
2
#include <boost/multi_index/ordered_index.hpp>
3
#include <boost/multi_index/member.hpp>
4
#include <string>
5
#include <iostream>
6
7
using namespace boost::multi_index;
8
9
struct Person {
10
int id;
11
std::string name;
12
13
Person(int id, const std::string& name) : id(id), name(name) {}
14
15
friend std::ostream& operator<<(std::ostream& os, const Person& person) {
16
os << "ID: " << person.id << ", Name: " << person.name;
17
return os;
18
}
19
};
20
21
// 定义 multi_index_container (与上例相同)
22
typedef multi_index_container<
23
Person,
24
indexed_by<
25
ordered_unique<member<Person, int, &Person::id>>
26
>
27
> PersonContainer;
28
29
int main() {
30
PersonContainer persons;
31
persons.emplace(1, "Alice");
32
persons.emplace(2, "Bob");
33
persons.emplace(3, "Charlie");
34
35
std::cout << "容器初始大小: " << persons.size() << std::endl; // 输出 "容器初始大小: 3"
36
37
// 使用 clear 删除所有元素
38
persons.clear();
39
std::cout << "清空容器后，容器大小: " << persons.size() << std::endl; // 输出 "清空容器后，容器大小: 0"
40
41
return 0;
42
}
在这个例子中，persons.clear() 删除了 PersonContainer 中的所有元素。
返回值
⚝ erase(iterator) 和 erase(range_iterator_first, range_iterator_last) 返回指向被删除元素之后位置的迭代器。
⚝ erase(key) 返回删除的元素数量。
⚝ clear() 没有返回值。
迭代器失效
⚝ 当使用迭代器删除元素时，指向被删除元素的迭代器会失效。
⚝ 删除范围内的元素时，范围 [first, last) 内的所有迭代器都会失效。
⚝ clear() 操作会使所有迭代器失效。
性能考量
erase 和 clear 操作的性能取决于索引类型和删除元素的数量。删除单个元素通常是高效的，尤其是在哈希索引和有序索引中。删除大量元素或清空容器可能需要更多时间，因为它涉及到多个索引的更新。
总结来说，erase 和 clear 是 Boost.MultiIndex 提供的用于删除容器中元素的基本操作。erase 提供了灵活的删除方式，可以删除单个元素、范围内的元素或按键值删除元素。clear 用于快速清空整个容器。理解这些操作的用法、返回值和迭代器失效规则，可以有效地管理 Boost.MultiIndex 容器中的数据。
4.6 迭代器 (Iterators) - 不同索引的迭代器
Boost.MultiIndex 容器的核心特性之一是它提供了多个索引视图，每个视图都支持迭代器，允许你以不同的顺序遍历容器中的元素。由于 multi_index_container 维护了多个索引，因此迭代器的行为和特性会根据所使用的索引类型而有所不同。
迭代器的类型
对于 multi_index_container，你可以通过 get<N>() 方法获取第 N 个索引的视图，每个索引视图都提供了自己的迭代器类型。常见的迭代器类型包括：
⚝ iterator 和 const_iterator: 用于遍历容器中的元素。iterator 允许修改元素（在允许的情况下，例如非键值成员），const_iterator 提供只读访问。
⚝ reverse_iterator 和 const_reverse_iterator: 以逆序遍历容器中的元素。
⚝ local_iterator 和 const_local_iterator: 用于在哈希索引中遍历特定哈希桶 (bucket) 内的元素。
不同索引的迭代器特性
⚝ 有序索引 (ordered_index):
▮▮▮▮⚝ 迭代器按照键值的排序顺序遍历元素。
▮▮▮▮⚝ begin() 返回指向第一个元素的迭代器（按排序顺序）。
▮▮▮▮⚝ end() 返回指向末尾的迭代器。
▮▮▮▮⚝ 支持双向迭代器，可以进行 ++ 和 -- 操作。
▮▮▮▮⚝ rbegin() 和 rend() 提供逆序迭代器。
⚝ 哈希索引 (hashed_index):
▮▮▮▮⚝ 迭代器遍历元素的顺序不保证与插入顺序或键值顺序一致，而是哈希表内部的存储顺序。
▮▮▮▮⚝ begin() 和 end() 返回的迭代器遍历整个哈希表。
▮▮▮▮⚝ 支持前向迭代器，可以进行 ++ 操作，但不保证 -- 操作的有效性。
▮▮▮▮⚝ local_iterator 和 cbegin(size_type n)/cend(size_type n) 用于遍历第 n 个哈希桶内的元素。这在某些高级应用中可以提高局部性。
⚝ 序列索引 (sequenced_index):
▮▮▮▮⚝ 迭代器按照元素插入容器的顺序遍历元素。
▮▮▮▮⚝ begin() 返回指向第一个插入元素的迭代器。
▮▮▮▮⚝ end() 返回指向末尾的迭代器。
▮▮▮▮⚝ 支持双向迭代器。
▮▮▮▮⚝ rbegin() 和 rend() 提供逆序迭代器（逆插入顺序）。
⚝ 随机访问索引 (random_access_index):
▮▮▮▮⚝ 迭代器支持随机访问，类似于 std::vector 的迭代器。
▮▮▮▮⚝ 可以通过索引位置直接访问元素。
▮▮▮▮⚝ begin() 返回指向第一个元素的迭代器。
▮▮▮▮⚝ end() 返回指向末尾的迭代器。
▮▮▮▮⚝ 支持随机访问迭代器，可以进行 ++, --, +n, -n, [] 等操作。
使用迭代器遍历容器
要遍历 multi_index_container，你需要首先获取特定索引的视图，然后使用该视图的迭代器。
1
#include <boost/multi_index_container.hpp>
2
#include <boost/multi_index/ordered_index.hpp>
3
#include <boost/multi_index/member.hpp>
4
#include <string>
5
#include <iostream>
6
7
using namespace boost::multi_index;
8
9
struct Person {
10
int id;
11
std::string name;
12
13
Person(int id, const std::string& name) : id(id), name(name) {}
14
15
friend std::ostream& operator<<(std::ostream& os, const Person& person) {
16
os << "ID: " << person.id << ", Name: " << person.name;
17
return os;
18
}
19
};
20
21
// 定义 multi_index_container，使用 id 作为有序索引，name 作为序列索引
22
typedef multi_index_container<
23
Person,
24
indexed_by<
25
ordered_unique<member<Person, int, &Person::id>>, // 按 id 排序的唯一索引 (索引 #0)
26
sequenced<> // 按插入顺序的序列索引 (索引 #1)
27
>
28
> PersonContainer;
29
30
int main() {
31
PersonContainer persons;
32
persons.emplace(3, "Charlie");
33
persons.emplace(1, "Alice");
34
persons.emplace(2, "Bob");
35
36
// 获取按 id 排序的索引视图 (索引 #0)
37
auto& id_index = persons.get<0>();
38
std::cout << "按 ID 排序遍历:" << std::endl;
39
for (auto it = id_index.begin(); it != id_index.end(); ++it) {
40
std::cout << *it << std::endl;
41
}
42
// 输出 (按 ID 排序):
43
// 按 ID 排序遍历:
44
// ID: 1, Name: Alice
45
// ID: 2, Name: Bob
46
// ID: 3, Name: Charlie
47
48
// 获取序列索引视图 (索引 #1)
49
auto& sequenced_index = persons.get<1>();
50
std::cout << "\n按插入顺序遍历:" << std::endl;
51
for (auto it = sequenced_index.begin(); it != sequenced_index.end(); ++it) {
52
std::cout << *it << std::endl;
53
}
54
// 输出 (按插入顺序):
55
// 按插入顺序遍历:
56
// ID: 3, Name: Charlie
57
// ID: 1, Name: Alice
58
// ID: 2, Name: Bob
59
60
return 0;
61
}
在这个例子中，我们创建了一个 PersonContainer，它有两个索引：按 id 排序的 ordered_unique 索引（索引 #0）和按插入顺序的 sequenced 索引（索引 #1）。我们分别获取了这两个索引的视图，并使用它们的迭代器遍历容器，展示了不同的遍历顺序。
迭代器的有效性
⚝ 插入和删除操作可能会影响迭代器的有效性。一般来说，插入操作不会使现有迭代器失效（除非插入导致容器重新分配内存，例如对于 random_access_index，但这在 multi_index_container 中不常见）。删除操作会使指向被删除元素的迭代器失效，以及可能使其他迭代器失效，特别是对于 sequenced_index 和 random_access_index。
⚝ 在修改元素时，指向被修改元素的迭代器通常保持有效，但如果修改操作导致元素在索引中的位置发生变化（例如，修改了有序索引的键值），迭代器的行为可能会变得不可预测。
算法支持
Boost.MultiIndex 容器的迭代器与标准库算法兼容。你可以使用 std::for_each, std::transform, std::copy 等算法，结合 multi_index_container 的迭代器，进行各种数据处理操作。
总结来说，Boost.MultiIndex 提供了多种类型的迭代器，每种迭代器都与特定的索引类型关联，并具有不同的遍历顺序和特性。理解不同索引的迭代器行为，可以灵活地遍历和操作 multi_index_container 中的数据，充分利用其多索引的优势。正确使用迭代器，并注意迭代器的有效性，是高效使用 Boost.MultiIndex 的关键。
END_OF_CHAPTER
5. chapter 5： 高级特性 (Advanced Features)
5.1 索引集操作 (Index Set Operations)
Boost.MultiIndex 容器的强大之处不仅在于它能通过多个索引访问数据，还在于它提供了丰富的索引集操作 (Index Set Operations)。这些操作允许我们直接在特定的索引上执行集合操作，例如交集、并集、差集等，极大地增强了数据处理的灵活性和效率。
索引集操作主要通过 index_set 类来实现，每个索引都关联着一个 index_set 对象。我们可以通过 multi_index_container 的 get<N>() 方法获取第 N 个索引的 index_set。一旦获取了 index_set，我们就可以像操作标准的 std::set 或 std::unordered_set 一样进行各种集合操作。
以下是一些常见的索引集操作及其应用场景：
① 交集 (Intersection)：查找在多个索引条件下都满足的元素。
例如，在一个学生信息管理系统中，我们可能需要找出既是计算机专业又是三年级的学生。这可以通过在专业索引和年级索引上执行交集操作来实现。
② 并集 (Union)：合并多个索引条件下的元素集合。
例如，找出所有计算机专业学生和所有数学专业学生。这可以通过在专业索引上执行并集操作来实现。
③ 差集 (Difference)：找出在一个索引条件下满足，但在另一个索引条件下不满足的元素。
例如，找出所有计算机专业学生中，不是三年级的学生。这可以通过在计算机专业索引和三年级索引上执行差集操作来实现。
④ 对称差集 (Symmetric Difference)：找出只在一个索引条件下满足，而不同时在两个索引条件下都满足的元素。
例如，找出要么是计算机专业学生，要么是数学专业学生，但不同时是这两个专业的学生。
示例代码
假设我们有一个存储书籍信息的 multi_index_container，其中包含书名、作者和 ISBN 三个索引。
1
#include <boost/multi_index_container.hpp>
2
#include <boost/multi_index/ordered_index.hpp>
3
#include <boost/multi_index/hashed_index.hpp>
4
#include <boost/multi_index/member.hpp>
5
#include <string>
6
#include <iostream>
7
8
using namespace boost::multi_index;
9
10
// 书籍结构体
11
struct Book {
12
std::string title;
13
std::string author;
14
std::string isbn;
15
16
Book(std::string t, std::string a, std::string i) : title(t), author(a), isbn(i) {}
17
18
friend std::ostream& operator<<(std::ostream& os, const Book& book) {
19
os << "Title: " << book.title << ", Author: " << book.author << ", ISBN: " << book.isbn;
20
return os;
21
}
22
};
23
24
// 定义 multi_index_container
25
using book_container = multi_index_container<
26
Book,
27
indexed_by<
28
ordered_unique<member<Book, std::string, &Book::isbn>>, // ISBN 索引 (唯一，有序)
29
hashed_non_unique<member<Book, std::string, &Book::author>>, // 作者索引 (非唯一，哈希)
30
ordered_non_unique<member<Book, std::string, &Book::title>> // 书名索引 (非唯一，有序)
31
>
32
>;
33
34
int main() {
35
book_container books;
36
37
books.emplace("The Lord of the Rings", "J.R.R. Tolkien", "978-0618260263");
38
books.emplace("The Hobbit", "J.R.R. Tolkien", "978-0345339683");
39
books.emplace("Pride and Prejudice", "Jane Austen", "978-0141439518");
40
books.emplace("Sense and Sensibility", "Jane Austen", "978-0141439518"); // ISBN 重复，但由于是 ordered_unique 索引，会插入失败，或者根据具体策略处理
41
42
// 获取作者索引的 index_set
43
auto& author_index = books.get<1>();
44
45
// 查找 Jane Austen 的书籍
46
auto range_jane_austen = author_index.equal_range("Jane Austen");
47
48
std::cout << "Books by Jane Austen:" << std::endl;
49
for (auto it = range_jane_austen.first; it != range_jane_austen.second; ++it) {
50
std::cout << *it << std::endl;
51
}
52
std::cout << std::endl;
53
54
55
// 获取书名索引的 index_set
56
auto& title_index = books.get<2>();
57
58
// 查找书名以 "The" 开头的书籍 (范围查询)
59
auto range_the_titles = title_index.lower_bound("The");
60
auto range_the_titles_end = title_index.upper_bound("The\xFF"); // '\xFF' 在 ASCII 中是最大字符，用于范围查询
61
62
std::cout << "Books with titles starting with 'The':" << std::endl;
63
for (auto it = range_the_titles; it != range_the_titles_end; ++it) {
64
std::cout << *it << std::endl;
65
}
66
std::cout << std::endl;
67
68
69
// 假设我们需要找到既是 Jane Austen 写的，书名又以 "Sense" 开头的书籍 (交集概念)
70
// 虽然 Boost.MultiIndex 没有直接的交集操作，但可以通过迭代和条件判断模拟
71
72
std::cout << "Books by Jane Austen with titles starting with 'Sense':" << std::endl;
73
for (auto it_author = range_jane_austen.first; it_author != range_jane_austen.second; ++it_author) {
74
if (it_author->title.rfind("Sense", 0) == 0) { // 检查书名是否以 "Sense" 开头
75
std::cout << *it_author << std::endl;
76
}
77
}
78
79
80
return 0;
81
}
代码解释
⚝ 我们定义了一个 book_container，它使用 ordered_unique 索引 ISBN，hashed_non_unique 索引作者，以及 ordered_non_unique 索引书名。
⚝ 通过 books.get<1>() 和 books.get<2>() 分别获取了作者索引和书名索引的 index_set。
⚝ 使用 equal_range 在作者索引上查找 "Jane Austen" 的书籍。
⚝ 使用 lower_bound 和 upper_bound 在书名索引上进行范围查询，查找书名以 "The" 开头的书籍。
⚝ 通过手动迭代和条件判断，模拟了交集操作，找到了既是 Jane Austen 写的，书名又以 "Sense" 开头的书籍。
总结
虽然 Boost.MultiIndex 没有直接提供如 set_intersection 等标准的集合算法用于 index_set，但我们可以通过 index_set 提供的查找和迭代功能，结合标准库算法或自定义逻辑，实现各种复杂的集合操作。这为我们基于多索引进行数据分析和处理提供了强大的工具。在实际应用中，可以根据具体需求，灵活运用这些操作，提高代码的效率和可读性。
5.2 对象持久化 (Object Persistence) 与序列化 (Serialization)
对象持久化 (Object Persistence) 和 序列化 (Serialization) 是软件开发中至关重要的概念，尤其是在需要存储数据到磁盘或通过网络传输数据时。对于 Boost.MultiIndex 容器，我们同样需要考虑如何将其状态保存下来，并在需要时恢复。
序列化 是将对象的状态转换为可以存储或传输的格式（如字节流、文本）的过程。反序列化 则是将序列化后的数据恢复为对象的过程。
Boost.MultiIndex 容器本身并不直接提供序列化和反序列化的功能，但由于它是一个符合标准库容器概念的容器，我们可以利用现有的 C++ 序列化库，例如 Boost.Serialization，来实现 MultiIndex 容器的持久化。
使用 Boost.Serialization 序列化 MultiIndex 容器
Boost.Serialization 是一个强大且灵活的 C++ 序列化库，它可以处理各种复杂的数据结构，包括标准库容器和自定义类。要使用 Boost.Serialization 序列化 MultiIndex 容器，我们需要做以下几步：
① 包含头文件：引入 Boost.Serialization 相关的头文件。
② 使类可序列化：确保存储在 MultiIndex 容器中的元素类型（例如 Book 结构体）是可序列化的。这通常需要为该类型定义 serialize 函数，或者使用 Boost.Serialization 提供的宏来自动生成序列化代码。
③ 序列化容器：使用 Boost.Serialization 提供的归档类（例如 boost::archive::binary_oarchive 用于二进制输出归档，boost::archive::text_oarchive 用于文本输出归档）将 MultiIndex 容器写入到输出流（例如文件流）。
④ 反序列化容器：使用相应的输入归档类（例如 boost::archive::binary_iarchive，boost::archive::text_iarchive）从输入流中读取数据，恢复 MultiIndex 容器。
示例代码
以下代码示例演示了如何使用 Boost.Serialization 序列化和反序列化之前定义的 book_container。
1
#include <boost/multi_index_container.hpp>
2
#include <boost/multi_index/ordered_index.hpp>
3
#include <boost/multi_index/hashed_index.hpp>
4
#include <boost/multi_index/member.hpp>
5
#include <string>
6
#include <iostream>
7
#include <fstream>
8
9
#include <boost/archive/binary_oarchive.hpp>
10
#include <boost/archive/binary_iarchive.hpp>
11
12
namespace boost {
13
namespace serialization {
14
15
// 使 Book 结构体可序列化
16
template<class Archive>
17
void serialize(Archive & ar, Book & b, const unsigned int version)
18
{
19
ar & b.title;
20
ar & b.author;
21
ar & b.isbn;
22
}
23
24
} // namespace serialization
25
} // namespace boost
26
27
28
using namespace boost::multi_index;
29
30
// 书籍结构体 (与之前相同)
31
struct Book {
32
std::string title;
33
std::string author;
34
std::string isbn;
35
36
Book() {} // 默认构造函数，序列化需要
37
Book(std::string t, std::string a, std::string i) : title(t), author(a), isbn(i) {}
38
39
friend std::ostream& operator<<(std::ostream& os, const Book& book) {
40
os << "Title: " << book.title << ", Author: " << book.author << ", ISBN: " << book.isbn;
41
return os;
42
}
43
44
friend bool operator==(const Book& lhs, const Book& rhs) { // 用于比较反序列化后的容器是否一致
45
return lhs.title == rhs.title && lhs.author == rhs.author && lhs.isbn == rhs.isbn;
46
}
47
};
48
49
// 定义 multi_index_container (与之前相同)
50
using book_container = multi_index_container<
51
Book,
52
indexed_by<
53
ordered_unique<member<Book, std::string, &Book::isbn>>,
54
hashed_non_unique<member<Book, std::string, &Book::author>>,
55
ordered_non_unique<member<Book, std::string, &Book::title>>
56
>
57
>;
58
59
int main() {
60
book_container books_original;
61
62
books_original.emplace("The Lord of the Rings", "J.R.R. Tolkien", "978-0618260263");
63
books_original.emplace("The Hobbit", "J.R.R. Tolkien", "978-0345339683");
64
books_original.emplace("Pride and Prejudice", "Jane Austen", "978-0141439518");
65
66
67
// 序列化到文件
68
{
69
std::ofstream ofs("books.dat", std::ios::binary);
70
boost::archive::binary_oarchive oa(ofs);
71
oa << books_original; // 序列化容器
72
}
73
74
book_container books_loaded;
75
76
// 从文件反序列化
77
{
78
std::ifstream ifs("books.dat", std::ios::binary);
79
boost::archive::binary_iarchive ia(ifs);
80
ia >> books_loaded; // 反序列化容器
81
}
82
83
// 验证反序列化后的容器是否与原始容器一致
84
bool are_equal = true;
85
if (books_original.size() != books_loaded.size()) {
86
are_equal = false;
87
} else {
88
auto it_original = books_original.begin();
89
auto it_loaded = books_loaded.begin();
90
for (; it_original != books_original.end(); ++it_original, ++it_loaded) {
91
if (!(*it_original == *it_loaded)) {
92
are_equal = false;
93
break;
94
}
95
}
96
}
97
98
if (are_equal) {
99
std::cout << "Serialization and deserialization successful!" << std::endl;
100
std::cout << "Loaded books:" << std::endl;
101
for (const auto& book : books_loaded) {
102
std::cout << book << std::endl;
103
}
104
} else {
105
std::cout << "Serialization or deserialization failed!" << std::endl;
106
}
107
108
109
return 0;
110
}
代码解释
⚝ 我们包含了 <boost/archive/binary_oarchive.hpp> 和 <boost/archive/binary_iarchive.hpp> 头文件，用于二进制序列化和反序列化。
⚝ 在 boost::serialization 命名空间中，为 Book 结构体定义了 serialize 函数，指定了需要序列化的成员变量 (title, author, isbn)。
⚝ 在 main 函数中，我们首先创建并填充了 books_original 容器。
⚝ 使用 boost::archive::binary_oarchive 将 books_original 序列化到名为 "books.dat" 的二进制文件中。
⚝ 创建空的 books_loaded 容器，并使用 boost::archive::binary_iarchive 从 "books.dat" 文件中反序列化数据到 books_loaded 容器。
⚝ 最后，我们比较了 books_original 和 books_loaded 容器的内容，验证序列化和反序列化是否成功。
总结
通过 Boost.Serialization 库，我们可以方便地实现 Boost.MultiIndex 容器的序列化和反序列化。这使得我们可以将 MultiIndex 容器的状态持久化到磁盘，或者通过网络传输，为构建需要数据持久化或分布式处理的应用提供了基础。在实际应用中，可以根据需求选择不同的归档格式（二进制或文本）和序列化库，例如 Protocol Buffers, Apache Thrift 等。
5.3 自定义索引类型 (Custom Index Types) 简介
Boost.MultiIndex 库提供了多种内置的索引类型，如 ordered_index, hashed_index, sequenced_index, random_access_index 等，这些索引类型已经能够满足大部分的应用场景。然而，在某些特殊情况下，我们可能需要更定制化的索引行为。Boost.MultiIndex 允许用户 自定义索引类型 (Custom Index Types)，以满足这些高级需求。
自定义索引类型允许我们：
① 实现特定的排序或查找逻辑：例如，基于复杂的比较函数或自定义哈希函数进行排序或查找。
② 扩展索引的功能：例如，添加额外的统计信息或触发特定的事件。
③ 优化特定场景的性能：例如，针对特定的数据分布或访问模式进行优化。
自定义索引类型的基本步骤
要创建一个自定义索引类型，通常需要以下步骤：
① 定义索引标签 (Index Tag)：为自定义索引类型创建一个唯一的标签，用于在 indexed_by 中标识该索引。
② 定义索引规范 (Index Specifier)：创建一个类或结构体，作为索引的规范。这个规范类需要继承自 multi_index::index_specifier，并包含必要的成员类型和静态成员函数，以描述索引的行为。
③ 实现索引操作：在索引规范类中，可以重载或实现特定的成员函数，例如 key_extractor, comparison_predicate, hash_function 等，以定制索引的键提取、排序、哈希等行为。
④ 在 indexed_by 中使用自定义索引类型：在定义 multi_index_container 时，在 indexed_by 中使用自定义索引类型的标签。
示例 (概念性代码)
以下是一个非常简化的概念性示例，展示了自定义索引类型的基本结构。请注意，这只是一个框架，实际的自定义索引类型可能需要更复杂的实现。
1
#include <boost/multi_index_container.hpp>
2
#include <boost/multi_index/indexed_by.hpp>
3
#include <boost/multi_index/index_specifier.hpp>
4
#include <boost/multi_index/key_extractors.hpp>
5
#include <string>
6
#include <iostream>
7
8
using namespace boost::multi_index;
9
10
// 1. 定义索引标签
11
struct custom_index_tag {};
12
13
// 2. 定义索引规范 (简化示例)
14
struct custom_index_spec : public index_specifier<custom_index_tag> {
15
// 可以重载或实现特定的成员类型和函数，例如 key_extractor, comparison_predicate 等
16
// ...
17
};
18
19
20
struct MyData {
21
int id;
22
std::string name;
23
};
24
25
// 定义 multi_index_container，使用自定义索引类型
26
using my_container = multi_index_container<
27
MyData,
28
indexed_by<
29
custom_index_spec, // 使用自定义索引类型
30
ordered_unique<member<MyData, int, &MyData::id>> // 仍然可以混合使用内置索引类型
31
>
32
>;
33
34
int main() {
35
my_container mc;
36
// ... 使用 mc
37
return 0;
38
}
总结
自定义索引类型是 Boost.MultiIndex 的一个高级特性，它提供了极大的灵活性，允许用户根据具体需求定制索引的行为。虽然自定义索引类型的实现相对复杂，但对于需要高度定制化索引功能的场景，它是一个非常有价值的工具。在实际应用中，需要深入理解 Boost.MultiIndex 的文档和示例，才能有效地使用自定义索引类型。本节仅为简介，更深入的细节将在后续更高级的Boost.MultiIndex主题中探讨。
5.4 性能考量与优化 (Performance Considerations and Optimization)
Boost.MultiIndex 提供了强大的多索引数据管理能力，但在追求功能性的同时，我们也需要关注其 性能 (Performance)，包括运行速度和内存占用。合理的性能优化对于构建高效的应用至关重要。
5.4.1 索引选择对性能的影响 (Impact of Index Choice on Performance)
不同的索引类型在性能上有着显著的差异。选择合适的索引类型是优化 Boost.MultiIndex 容器性能的关键步骤。
① 有序索引 (ordered_index)：
⚝ 优点：支持高效的范围查询、排序遍历。基于比较操作，适用于需要排序和范围查找的场景。
⚝ 缺点：插入、删除和查找的平均时间复杂度为 \(O(\log N)\)，其中 N 是容器中元素的数量。对于大量数据的频繁插入和删除，性能可能不如哈希索引。
⚝ 适用场景：需要排序、范围查询、有序遍历的数据集。例如，日志数据、时间序列数据、需要按顺序访问的数据。
② 哈希索引 (hashed_index)：
⚝ 优点：平均查找、插入、删除的时间复杂度为 \(O(1)\)。对于精确匹配的查找操作非常高效。
⚝ 缺点：不支持范围查询、排序遍历。哈希冲突可能导致性能下降。
⚝ 适用场景：主要用于精确匹配查找，不需要排序或范围查询的数据集。例如，缓存、键值存储、快速查找特定 ID 的数据。
③ 序列索引 (sequenced_index)：
⚝ 优点：插入和删除操作非常快，时间复杂度为 \(O(1)\)。保持元素插入顺序。
⚝ 缺点：查找操作需要遍历，时间复杂度为 \(O(N)\)。不适合频繁查找的场景。
⚝ 适用场景：需要维护插入顺序，主要进行顺序访问，插入和删除操作频繁的数据集。例如，任务队列、事件队列。
④ 随机访问索引 (random_access_index)：
⚝ 优点：支持通过索引下标进行快速随机访问，时间复杂度为 \(O(1)\)。
⚝ 缺点：插入和删除操作可能导致元素移动，时间复杂度为 \(O(N)\)。不适合频繁插入和删除的场景。
⚝ 适用场景：需要通过下标随机访问元素的数据集。例如，需要像数组一样访问的元素集合。
选择索引类型的原则
⚝ 根据主要操作选择：如果主要操作是范围查询和排序，选择 ordered_index；如果主要操作是精确匹配查找，选择 hashed_index；如果主要操作是顺序访问和频繁插入删除，选择 sequenced_index；如果需要下标随机访问，选择 random_access_index。
⚝ 组合使用索引类型：根据不同的访问模式，组合使用多种索引类型。例如，可以使用 ordered_index 进行范围查询，同时使用 hashed_index 进行快速精确查找。
⚝ 考虑数据量和操作频率：对于大数据量和高频率操作，索引类型的性能差异会更加明显。需要根据实际情况进行性能测试和评估。
示例
假设我们需要管理一个学生信息系统，需要根据学号快速查找学生（精确匹配），也需要根据成绩范围查询学生（范围查询）。
⚝ 学号查找：使用 hashed_unique 索引学号，可以实现 \(O(1)\) 的快速查找。
⚝ 成绩范围查询：使用 ordered_non_unique 索引成绩，可以高效地进行范围查询。
通过组合使用 hashed_index 和 ordered_index，我们可以兼顾精确查找和范围查询的性能需求。
5.4.2 内存占用 (Memory Footprint)
Boost.MultiIndex 容器的 内存占用 (Memory Footprint) 主要由以下几个方面决定：
① 元素本身的大小：存储的元素越大，容器占用的内存越多。
② 索引的数量和类型：每个索引都会增加额外的内存开销。索引类型越复杂（例如 ordered_index），内存开销可能相对较高。
③ 容器的容量 (Capacity)：虽然 multi_index_container 会动态调整大小，但预留一定的容量可以减少内存重新分配的次数，提高性能。
优化内存占用的方法
⚝ 选择必要的索引：只创建真正需要的索引，避免创建过多的索引，减少额外的内存开销。
⚝ 使用轻量级的键提取器：键提取器的实现效率也会影响性能和内存占用。尽量使用高效的键提取器，例如成员指针键提取器 member，避免不必要的拷贝和计算。
⚝ 减小元素大小：如果元素本身占用内存较大，可以考虑优化元素结构，例如使用更紧凑的数据类型，或者使用指针指向外部数据。
⚝ 使用 trim() 方法：multi_index_container 提供了 trim() 方法，可以释放容器中未使用的内存，减小内存占用。
⚝ 合理预估容器大小：在创建容器时，可以根据预估的数据量，使用 reserve() 方法预留一定的容量，减少内存重新分配的次数。
内存占用分析工具
可以使用内存分析工具（例如 Valgrind, Massif）来分析 Boost.MultiIndex 容器的内存占用情况，找出内存瓶颈，并进行针对性的优化。
总结
性能和内存占用是 Boost.MultiIndex 应用中需要重点关注的方面。通过合理选择索引类型、优化键提取器、减小元素大小、使用 trim() 方法等手段，可以有效地提高 Boost.MultiIndex 容器的性能，并降低内存占用。在实际应用中，需要根据具体场景进行性能测试和分析，找到最佳的性能优化方案。
END_OF_CHAPTER
6. chapter 6： 实战案例 (Practical Case Studies)
6.1 案例一：学生信息管理系统 (Case Study 1: Student Information Management System)
6.1.1 需求分析 (Requirement Analysis)
学生信息管理系统是一个常见的应用场景，其核心需求是对学生信息进行高效的管理和检索。在这个案例中，我们希望使用 Boost.MultiIndex 来构建一个灵活且高性能的学生信息管理系统。具体的需求包括：
① 基本信息管理：能够存储和管理学生的基本信息，例如：
▮▮▮▮ⓑ 学号 (Student ID)：学生的唯一标识符，例如 2023001。
▮▮▮▮ⓒ 姓名 (Name)：学生的姓名，例如 张三。
▮▮▮▮ⓓ 年龄 (Age)：学生的年龄，例如 18。
▮▮▮▮ⓔ 班级 (Class)：学生所在的班级，例如 Class 1。
▮▮▮▮ⓕ 成绩 (Score)：学生的考试成绩，例如 95.5。
② 多维度检索：能够根据不同的条件快速检索学生信息：
▮▮▮▮ⓑ 按学号快速查找学生。
▮▮▮▮ⓒ 按姓名查找学生（可能存在同名学生）。
▮▮▮▮ⓓ 按班级查找学生。
▮▮▮▮ⓔ 按成绩范围查找学生。
▮▮▮▮ⓕ 按年龄范围查找学生。
③ 排序功能：能够根据不同的字段对学生信息进行排序：
▮▮▮▮ⓑ 按学号排序。
▮▮▮▮ⓒ 按姓名排序。
▮▮▮▮ⓓ 按年龄排序。
▮▮▮▮ⓔ 按班级排序。
▮▮▮▮ⓕ 按成绩排序。
④ 动态更新：能够方便地添加、删除和修改学生信息。
为了满足以上需求，传统的做法可能需要维护多个容器，并针对不同的检索和排序需求编写不同的代码。而使用 Boost.MultiIndex，我们可以在一个容器中建立多个索引，从而高效地支持多维度的检索和排序，简化代码并提高性能。
6.1.2 设计与实现 (Design and Implementation)
针对学生信息管理系统的需求，我们可以设计一个 multi_index_container 来存储学生信息，并建立多个索引以支持不同的查询和排序方式。
① 数据结构设计：
首先，我们定义一个 Student 结构体来存储学生的基本信息：
1
struct Student {
2
int id; // 学号
3
std::string name; // 姓名
4
int age; // 年龄
5
std::string className; // 班级
6
double score; // 成绩
7
8
Student(int id, const std::string& name, int age, const std::string& className, double score)
9
: id(id), name(name), age(age), className(className), score(score) {}
10
11
friend std::ostream& operator<<(std::ostream& os, const Student& student) {
12
os << "ID: " << student.id << ", Name: " << student.name
13
<< ", Age: " << student.age << ", Class: " << student.className
14
<< ", Score: " << student.score;
15
return os;
16
}
17
};
② Multi-index 容器设计：
接下来，我们定义 multi_index_container，并为其添加多个索引：
为了支持按学号快速查找（唯一），我们使用 ordered_unique 索引，以 id 作为键。
为了支持按姓名查找（非唯一，可能同名），我们使用 ordered_non_unique 索引，以 name 作为键。
为了支持按班级查找和排序，我们使用 ordered_non_unique 索引，以 className 作为键。
为了支持按成绩范围查找和排序，我们使用 ordered_non_unique 索引，以 score 作为键。
为了支持按年龄范围查找和排序，我们使用 ordered_non_unique 索引，以 age 作为键。
基于以上分析，我们定义 multi_index_container 如下：
1
#include <boost/multi_index_container.hpp>
2
#include <boost/multi_index/ordered_index.hpp>
3
#include <boost/multi_index/identity.hpp>
4
#include <boost/multi_index/member.hpp>
5
6
using namespace boost::multi_index;
7
8
// 定义 multi_index_container
9
typedef multi_index_container<
10
Student,
11
indexed_by<
12
ordered_unique< // 索引 0: 按学号 (id) 唯一排序
13
member<Student, int, &Student::id>
14
>,
15
ordered_non_unique< // 索引 1: 按姓名 (name) 排序
16
member<Student, std::string, &Student::name>
17
>,
18
ordered_non_unique< // 索引 2: 按班级 (className) 排序
19
member<Student, std::string, &Student::className>
20
>,
21
ordered_non_unique< // 索引 3: 按成绩 (score) 排序
22
member<Student, double, &Student::score>
23
>,
24
ordered_non_unique< // 索引 4: 按年龄 (age) 排序
25
member<Student, int, &Student::age>
26
>
27
>
28
> student_container;
在这个定义中，我们使用了 indexed_by 来组合多个索引，每个索引都使用 ordered_... 类型，并使用 member 键提取器来指定排序的键。identity<> 用于第一个索引，表示直接使用对象本身作为键（实际上在这里我们用 member 更清晰地指定了 id）。
③ 常用操作接口设计：
为了方便使用，我们可以封装一些常用的操作接口，例如：
⚝ 添加学生：add_student(const Student& student)
⚝ 按学号查找学生：find_student_by_id(int id)
⚝ 按姓名查找学生：find_students_by_name(const std::string& name)
⚝ 按班级查找学生：find_students_by_class(const std::string& className)
⚝ 按成绩范围查找学生：find_students_by_score_range(double minScore, double maxScore)
⚝ 按年龄范围查找学生：find_students_by_age_range(int minAge, int maxAge)
⚝ 遍历所有学生（按学号排序）：print_all_students_by_id()
⚝ 遍历所有学生（按姓名排序）：print_all_students_by_name()
⚝ ... 等等
6.1.3 代码详解 (Code Details)
下面我们来实现上述设计，并给出代码示例。
① 包含头文件和命名空间：
1
#include <iostream>
2
#include <string>
3
#include <boost/multi_index_container.hpp>
4
#include <boost/multi_index/ordered_index.hpp>
5
#include <boost/multi_index/identity.hpp>
6
#include <boost/multi_index/member.hpp>
7
8
using namespace boost::multi_index;
② Student 结构体定义 (同 6.1.2 节)：
1
struct Student { /* ... */ };
③ student_container 类型定义 (同 6.1.2 节)：
1
typedef multi_index_container< /* ... */ > student_container;
④ 添加学生函数：
1
void add_student(student_container& students, const Student& student) {
2
students.insert(student);
3
}
⑤ 按学号查找学生函数：
1
student_container::index<0>::type::iterator find_student_by_id(student_container& students, int id) {
2
auto& id_index = students.get<0>(); // 获取按学号排序的索引
3
return id_index.find(id);
4
}
这里 students.get<0>() 获取索引为 0 的索引（即按学号排序的 ordered_unique 索引）。id_index.find(id) 在该索引上查找学号为 id 的学生。
⑥ 按姓名查找学生函数：
1
std::pair<student_container::index<1>::type::iterator, student_container::index<1>::type::iterator>
2
find_students_by_name(student_container& students, const std::string& name) {
3
auto& name_index = students.get<1>(); // 获取按姓名排序的索引
4
return name_index.equal_range(name); // 返回姓名等于 name 的范围
5
}
students.get<1>() 获取索引为 1 的索引（即按姓名排序的 ordered_non_unique 索引）。name_index.equal_range(name) 返回姓名等于 name 的元素的迭代器范围，因为姓名索引是非唯一的，可能存在多个同名学生。
⑦ 按班级查找学生函数：
1
std::pair<student_container::index<2>::type::iterator, student_container::index<2>::type::iterator>
2
find_students_by_class(student_container& students, const std::string& className) {
3
auto& class_index = students.get<2>(); // 获取按班级排序的索引
4
return class_index.equal_range(className); // 返回班级等于 className 的范围
5
}
⑧ 按成绩范围查找学生函数：
1
std::pair<student_container::index<3>::type::iterator, student_container::index<3>::type::iterator>
2
find_students_by_score_range(student_container& students, double minScore, double maxScore) {
3
auto& score_index = students.get<3>(); // 获取按成绩排序的索引
4
return score_index.range(minScore, maxScore); // 返回成绩在 [minScore, maxScore] 范围内的学生
5
}
score_index.range(minScore, maxScore) 返回成绩在 [minScore, maxScore] 范围内的元素的迭代器范围。
⑨ 按年龄范围查找学生函数：
1
std::pair<student_container::index<4>::type::iterator, student_container::index<4>::type::iterator>
2
find_students_by_age_range(student_container& students, int minAge, int maxAge) {
3
auto& age_index = students.get<4>(); // 获取按年龄排序的索引
4
return age_index.range(minAge, maxAge); // 返回年龄在 [minAge, maxAge] 范围内的学生
5
}
⑩ 遍历所有学生（按学号排序）函数：
1
void print_all_students_by_id(student_container& students) {
2
auto& id_index = students.get<0>(); // 获取按学号排序的索引
3
std::cout << "Students sorted by ID:" << std::endl;
4
for (const auto& student : id_index) {
5
std::cout << student << std::endl;
6
}
7
}
⑪ 遍历所有学生（按姓名排序）函数：
1
void print_all_students_by_name(student_container& students) {
2
auto& name_index = students.get<1>(); // 获取按姓名排序的索引
3
std::cout << "Students sorted by Name:" << std::endl;
4
for (const auto& student : name_index) {
5
std::cout << student << std::endl;
6
}
7
}
⑫ main 函数示例：
1
int main() {
2
student_container students;
3
4
add_student(students, Student(2023001, "张三", 18, "Class 1", 95.5));
5
add_student(students, Student(2023002, "李四", 19, "Class 2", 88.0));
6
add_student(students, Student(2023003, "王五", 18, "Class 1", 92.0));
7
add_student(students, Student(2023004, "张三", 20, "Class 3", 78.5)); // 同名学生
8
9
std::cout << "--- Find student by ID: 2023002 ---" << std::endl;
10
auto it_id = find_student_by_id(students, 2023002);
11
if (it_id != students.get<0>().end()) {
12
std::cout << *it_id << std::endl;
13
}
14
15
std::cout << "--- Find students by name: 张三 ---" << std::endl;
16
auto range_name = find_students_by_name(students, "张三");
17
for (auto it = range_name.first; it != range_name.second; ++it) {
18
std::cout << *it << std::endl;
19
}
20
21
std::cout << "--- Find students in class: Class 1 ---" << std::endl;
22
auto range_class = find_students_by_class(students, "Class 1");
23
for (auto it = range_class.first; it != range_class.second; ++it) {
24
std::cout << *it << std::endl;
25
}
26
27
std::cout << "--- Find students with score in range [90, 100] ---" << std::endl;
28
auto range_score = find_students_by_score_range(students, 90.0, 100.0);
29
for (auto it = range_score.first; it != range_score.second; ++it) {
30
std::cout << *it << std::endl;
31
}
32
33
std::cout << "--- Find students with age in range [18, 19] ---" << std::endl;
34
auto range_age = find_students_by_age_range(students, 18, 19);
35
for (auto it = range_age.first; it != range_age.second; ++it) {
36
std::cout << *it << std::endl;
37
}
38
39
std::cout << "--- All students sorted by ID ---" << std::endl;
40
print_all_students_by_id(students);
41
42
std::cout << "--- All students sorted by Name ---" << std::endl;
43
print_all_students_by_name(students);
44
45
return 0;
46
}
这个完整的示例代码展示了如何使用 Boost.MultiIndex 构建一个简单的学生信息管理系统，并实现了按学号、姓名、班级、成绩和年龄进行查找和排序的功能。通过这个案例，读者可以初步了解 Boost.MultiIndex 在实际应用中的价值和用法。
6.2 案例二：游戏角色管理 (Case Study 2: Game Character Management)
6.2.1 需求分析 (Requirement Analysis)
在游戏开发中，角色管理是一个核心模块。我们需要高效地管理大量的游戏角色，并支持多种查询和排序操作。假设我们正在开发一个角色扮演游戏 (RPG)，我们需要管理游戏中的角色信息。具体的需求包括：
① 角色基本属性管理：存储和管理角色的基本属性，例如：
▮▮▮▮ⓑ 角色 ID (Character ID)：角色的唯一标识符，例如 char_1001。
▮▮▮▮ⓒ 角色名称 (Character Name)：角色的名称，例如 战士小明。
▮▮▮▮ⓓ 角色等级 (Level)：角色的等级，例如 15。
▮▮▮▮ⓔ 职业 (Class)：角色的职业，例如 战士、法师、牧师。
▮▮▮▮ⓕ 战斗力 (Power)：角色的战斗力数值，例如 2500。
② 多维度检索：能够根据不同的条件快速检索角色信息：
▮▮▮▮ⓑ 按角色 ID 快速查找角色。
▮▮▮▮ⓒ 按角色名称查找角色（可能存在同名角色）。
▮▮▮▮ⓓ 按职业查找角色。
▮▮▮▮ⓔ 按等级范围查找角色。
▮▮▮▮ⓕ 按战斗力范围查找角色。
③ 排序功能：能够根据不同的字段对角色信息进行排序：
▮▮▮▮ⓑ 按角色 ID 排序。
▮▮▮▮ⓒ 按角色名称排序。
▮▮▮▮ⓓ 按等级排序。
▮▮▮▮ⓔ 按职业排序。
▮▮▮▮ⓕ 按战斗力排序。
④ 高效更新：在游戏运行过程中，角色的属性（如等级、战斗力）可能会频繁更新，需要高效的更新机制。
使用 Boost.MultiIndex 可以方便地实现上述需求，在一个容器中维护多个索引，支持多维度的查询和排序，并提供高效的更新操作。
6.2.2 设计与实现 (Design and Implementation)
针对游戏角色管理系统的需求，我们设计一个 multi_index_container 来存储角色信息，并建立多个索引。
① 数据结构设计：
定义一个 GameCharacter 结构体来存储角色信息：
1
struct GameCharacter {
2
std::string id; // 角色 ID
3
std::string name; // 角色名称
4
int level; // 角色等级
5
std::string profession; // 职业
6
int power; // 战斗力
7
8
GameCharacter(const std::string& id, const std::string& name, int level, const std::string& profession, int power)
9
: id(id), name(name), level(level), profession(profession), power(power) {}
10
11
friend std::ostream& operator<<(std::ostream& os, const GameCharacter& character) {
12
os << "ID: " << character.id << ", Name: " << character.name
13
<< ", Level: " << character.level << ", Profession: " << character.profession
14
<< ", Power: " << character.power;
15
return os;
16
}
17
};
② Multi-index 容器设计：
定义 multi_index_container，并添加索引：
⚝ 按角色 ID 快速查找（唯一）：ordered_unique 索引，键为 id。
⚝ 按角色名称查找（非唯一）：ordered_non_unique 索引，键为 name。
⚝ 按职业查找和排序：ordered_non_unique 索引，键为 profession。
⚝ 按等级范围查找和排序：ordered_non_unique 索引，键为 level。
⚝ 按战斗力范围查找和排序：ordered_non_unique 索引，键为 power。
1
#include <boost/multi_index_container.hpp>
2
#include <boost/multi_index/ordered_index.hpp>
3
#include <boost/multi_index/identity.hpp>
4
#include <boost/multi_index/member.hpp>
5
6
using namespace boost::multi_index;
7
8
typedef multi_index_container<
9
GameCharacter,
10
indexed_by<
11
ordered_unique< // 索引 0: 按角色 ID (id) 唯一排序
12
member<GameCharacter, std::string, &GameCharacter::id>
13
>,
14
ordered_non_unique< // 索引 1: 按角色名称 (name) 排序
15
member<GameCharacter, std::string, &GameCharacter::name>
16
>,
17
ordered_non_unique< // 索引 2: 按职业 (profession) 排序
18
member<GameCharacter, std::string, &GameCharacter::profession>
19
>,
20
ordered_non_unique< // 索引 3: 按等级 (level) 排序
21
member<GameCharacter, int, &GameCharacter::level>
22
>,
23
ordered_non_unique< // 索引 4: 按战斗力 (power) 排序
24
member<GameCharacter, int, &GameCharacter::power>
25
>
26
>
27
> character_container;
③ 常用操作接口设计：
⚝ 添加角色：add_character(const GameCharacter& character)
⚝ 按角色 ID 查找角色：find_character_by_id(const std::string& id)
⚝ 按角色名称查找角色：find_characters_by_name(const std::string& name)
⚝ 按职业查找角色：find_characters_by_profession(const std::string& profession)
⚝ 按等级范围查找角色：find_characters_by_level_range(int minLevel, int maxLevel)
⚝ 按战斗力范围查找角色：find_characters_by_power_range(int minPower, int maxPower)
⚝ 更新角色等级：update_character_level(const std::string& id, int newLevel)
⚝ 遍历所有角色（按角色 ID 排序）：print_all_characters_by_id()
⚝ 遍历所有角色（按战斗力排序）：print_all_characters_by_power()
⚝ ... 等等
6.2.3 代码详解 (Code Details)
下面实现上述设计，并给出代码示例。
① 包含头文件和命名空间：
1
#include <iostream>
2
#include <string>
3
#include <boost/multi_index_container.hpp>
4
#include <boost/multi_index/ordered_index.hpp>
5
#include <boost/multi_index/identity.hpp>
6
#include <boost/multi_index/member.hpp>
7
8
using namespace boost::multi_index;
② GameCharacter 结构体定义 (同 6.2.2 节)：
1
struct GameCharacter { /* ... */ };
③ character_container 类型定义 (同 6.2.2 节)：
1
typedef multi_index_container< /* ... */ > character_container;
④ 添加角色函数：
1
void add_character(character_container& characters, const GameCharacter& character) {
2
characters.insert(character);
3
}
⑤ 按角色 ID 查找角色函数：
1
character_container::index<0>::type::iterator find_character_by_id(character_container& characters, const std::string& id) {
2
auto& id_index = characters.get<0>(); // 获取按角色 ID 排序的索引
3
return id_index.find(id);
4
}
⑥ 按角色名称查找角色函数：
1
std::pair<character_container::index<1>::type::iterator, character_container::index<1>::type::iterator>
2
find_characters_by_name(character_container& characters, const std::string& name) {
3
auto& name_index = characters.get<1>(); // 获取按角色名称排序的索引
4
return name_index.equal_range(name);
5
}
⑦ 按职业查找角色函数：
1
std::pair<character_container::index<2>::type::iterator, character_container::index<2>::type::iterator>
2
find_characters_by_profession(character_container& characters, const std::string& profession) {
3
auto& profession_index = characters.get<2>(); // 获取按职业排序的索引
4
return profession_index.equal_range(profession);
5
}
⑧ 按等级范围查找角色函数：
1
std::pair<character_container::index<3>::type::iterator, character_container::index<3>::type::iterator>
2
find_characters_by_level_range(character_container& characters, int minLevel, int maxLevel) {
3
auto& level_index = characters.get<3>(); // 获取按等级排序的索引
4
return level_index.range(minLevel, maxLevel);
5
}
⑨ 按战斗力范围查找角色函数：
1
std::pair<character_container::index<4>::type::iterator, character_container::index<4>::type::iterator>
2
find_characters_by_power_range(character_container& characters, int minPower, int maxPower) {
3
auto& power_index = characters.get<4>(); // 获取按战斗力排序的索引
4
return power_index.range(minPower, maxPower);
5
}
⑩ 更新角色等级函数：
1
bool update_character_level(character_container& characters, const std::string& id, int newLevel) {
2
auto it_id = find_character_by_id(characters, id);
3
if (it_id != characters.get<0>().end()) {
4
characters.modify(it_id, [&newLevel](GameCharacter& character) {
5
character.level = newLevel;
6
});
7
return true;
8
}
9
return false;
10
}
characters.modify(it_id, ...) 用于修改迭代器 it_id 指向的元素。第二个参数是一个 lambda 表达式，用于指定如何修改元素。
⑪ 遍历所有角色（按角色 ID 排序）函数：
1
void print_all_characters_by_id(character_container& characters) {
2
auto& id_index = characters.get<0>(); // 获取按角色 ID 排序的索引
3
std::cout << "Characters sorted by ID:" << std::endl;
4
for (const auto& character : id_index) {
5
std::cout << character << std::endl;
6
}
7
}
⑫ 遍历所有角色（按战斗力排序）函数：
1
void print_all_characters_by_power(character_container& characters) {
2
auto& power_index = characters.get<4>(); // 获取按战斗力排序的索引
3
std::cout << "Characters sorted by Power:" << std::endl;
4
for (const auto& character : power_index) {
5
std::cout << character << std::endl;
6
}
7
}
⑬ main 函数示例：
1
int main() {
2
character_container characters;
3
4
add_character(characters, GameCharacter("char_1001", "战士小明", 15, "战士", 2500));
5
add_character(characters, GameCharacter("char_1002", "法师小红", 12, "法师", 2200));
6
add_character(characters, GameCharacter("char_1003", "牧师老王", 18, "牧师", 1800));
7
add_character(characters, GameCharacter("char_1004", "战士小张", 15, "战士", 2600)); // 同职业角色
8
9
std::cout << "--- Find character by ID: char_1002 ---" << std::endl;
10
auto it_id = find_character_by_id(characters, "char_1002");
11
if (it_id != characters.get<0>().end()) {
12
std::cout << *it_id << std::endl;
13
}
14
15
std::cout << "--- Find characters by name: 战士小张 ---" << std::endl;
16
auto range_name = find_characters_by_name(characters, "战士小张");
17
for (auto it = range_name.first; it != range_name.second; ++it) {
18
std::cout << *it << std::endl;
19
}
20
21
std::cout << "--- Find characters by profession: 战士 ---" << std::endl;
22
auto range_profession = find_characters_by_profession(characters, "战士");
23
for (auto it = range_profession.first; it != range_profession.second; ++it) {
24
std::cout << *it << std::endl;
25
}
26
27
std::cout << "--- Find characters with level in range [10, 15] ---" << std::endl;
28
auto range_level = find_characters_by_level_range(characters, 10, 15);
29
for (auto it = range_level.first; it != range_level.second; ++it) {
30
std::cout << *it << std::endl;
31
}
32
33
std::cout << "--- Find characters with power in range [2000, 2500] ---" << std::endl;
34
auto range_power = find_characters_by_power_range(characters, 2000, 2500);
35
for (auto it = range_power.first; it != range_power.second; ++it) {
36
std::cout << *it << std::endl;
37
}
38
39
std::cout << "--- Update level of character char_1003 to 20 ---" << std::endl;
40
update_character_level(characters, "char_1003", 20);
41
it_id = find_character_by_id(characters, "char_1003");
42
if (it_id != characters.get<0>().end()) {
43
std::cout << *it_id << std::endl; // 验证等级是否更新
44
}
45
46
std::cout << "--- All characters sorted by ID ---" << std::endl;
47
print_all_characters_by_id(characters);
48
49
std::cout << "--- All characters sorted by Power ---" << std::endl;
50
print_all_characters_by_power(characters);
51
52
return 0;
53
}
这个案例展示了如何使用 Boost.MultiIndex 管理游戏角色信息，并实现了多维度的查询、排序和更新操作。通过这个案例，读者可以进一步理解 Boost.MultiIndex 在游戏开发等高性能场景下的应用。
6.3 案例三：网络连接管理器 (Case Study 3: Network Connection Manager)
6.3.1 需求分析 (Requirement Analysis)
网络连接管理器用于监控和管理网络连接，例如服务器程序需要管理客户端连接。我们需要高效地管理大量的网络连接信息，并支持多种查询和排序操作。具体的需求包括：
① 连接信息管理：存储和管理网络连接的基本信息，例如：
▮▮▮▮ⓑ 连接 ID (Connection ID)：连接的唯一标识符，例如 conn_001。
▮▮▮▮ⓒ 客户端 IP 地址 (Client IP)：客户端的 IP 地址，例如 192.168.1.100。
▮▮▮▮ⓓ 客户端端口 (Client Port)：客户端的端口号，例如 54321。
▮▮▮▮ⓔ 服务器端口 (Server Port)：服务器监听的端口号，例如 8080。
▮▮▮▮ⓕ 连接状态 (Status)：连接的状态，例如 Connected、Disconnected、Pending。
▮▮▮▮ⓖ 连接时间 (Connection Time)：连接建立的时间戳。
② 多维度检索：能够根据不同的条件快速检索连接信息：
▮▮▮▮ⓑ 按连接 ID 快速查找连接。
▮▮▮▮ⓒ 按客户端 IP 地址查找连接。
▮▮▮▮ⓓ 按服务器端口查找连接。
▮▮▮▮ⓔ 按连接状态查找连接。
▮▮▮▮ⓕ 按连接时间范围查找连接。
③ 排序功能：能够根据不同的字段对连接信息进行排序：
▮▮▮▮ⓑ 按连接 ID 排序。
▮▮▮▮ⓒ 按客户端 IP 地址排序。
▮▮▮▮ⓓ 按服务器端口排序。
▮▮▮▮ⓔ 按连接状态排序。
▮▮▮▮ⓕ 按连接时间排序。
④ 状态更新：网络连接的状态会动态变化，例如从 Pending 变为 Connected 或 Disconnected，需要高效的状态更新机制。
使用 Boost.MultiIndex 可以有效地管理网络连接信息，支持多维度的查询和排序，并提供高效的状态更新操作。
6.3.2 设计与实现 (Design and Implementation)
针对网络连接管理器的需求，我们设计一个 multi_index_container 来存储连接信息，并建立多个索引。
① 数据结构设计：
定义一个 NetworkConnection 结构体来存储连接信息：
1
#include <ctime> // for std::time_t, std::time, std::localtime, std::strftime
2
#include <iomanip> // for std::put_time
3
4
struct NetworkConnection {
5
std::string id; // 连接 ID
6
std::string clientIP; // 客户端 IP 地址
7
int clientPort; // 客户端端口
8
int serverPort; // 服务器端口
9
std::string status; // 连接状态
10
std::time_t connectionTime; // 连接时间 (时间戳)
11
12
NetworkConnection(const std::string& id, const std::string& clientIP, int clientPort, int serverPort, const std::string& status, std::time_t connectionTime)
13
: id(id), clientIP(clientIP), clientPort(clientPort), serverPort(serverPort), status(status), connectionTime(connectionTime) {}
14
15
friend std::ostream& operator<<(std::ostream& os, const NetworkConnection& conn) {
16
std::tm* timeinfo = std::localtime(&conn.connectionTime);
17
char buffer[80];
18
std::strftime(buffer, sizeof(buffer), "%Y-%m-%d %H:%M:%S", timeinfo);
19
20
os << "ID: " << conn.id << ", Client IP: " << conn.clientIP
21
<< ", Client Port: " << conn.clientPort << ", Server Port: " << conn.serverPort
22
<< ", Status: " << conn.status << ", Time: " << buffer;
23
return os;
24
}
25
};
这里使用了 std::time_t 来存储连接时间戳，并在输出时格式化为可读的时间字符串。
② Multi-index 容器设计：
定义 multi_index_container，并添加索引：
⚝ 按连接 ID 快速查找（唯一）：ordered_unique 索引，键为 id。
⚝ 按客户端 IP 地址查找（非唯一）：ordered_non_unique 索引，键为 clientIP。
⚝ 按服务器端口查找和排序：ordered_non_unique 索引，键为 serverPort。
⚝ 按连接状态查找和排序：ordered_non_unique 索引，键为 status。
⚝ 按连接时间排序：ordered_non_unique 索引，键为 connectionTime。
1
#include <boost/multi_index_container.hpp>
2
#include <boost/multi_index/ordered_index.hpp>
3
#include <boost/multi_index/identity.hpp>
4
#include <boost/multi_index/member.hpp>
5
6
using namespace boost::multi_index;
7
8
typedef multi_index_container<
9
NetworkConnection,
10
indexed_by<
11
ordered_unique< // 索引 0: 按连接 ID (id) 唯一排序
12
member<NetworkConnection, std::string, &NetworkConnection::id>
13
>,
14
ordered_non_unique< // 索引 1: 按客户端 IP (clientIP) 排序
15
member<NetworkConnection, std::string, &NetworkConnection::clientIP>
16
>,
17
ordered_non_unique< // 索引 2: 按服务器端口 (serverPort) 排序
18
member<NetworkConnection, int, &NetworkConnection::serverPort>
19
>,
20
ordered_non_unique< // 索引 3: 按连接状态 (status) 排序
21
member<NetworkConnection, std::string, &NetworkConnection::status>
22
>,
23
ordered_non_unique< // 索引 4: 按连接时间 (connectionTime) 排序
24
member<NetworkConnection, std::time_t, &NetworkConnection::connectionTime>
25
>
26
>
27
> connection_container;
③ 常用操作接口设计：
⚝ 添加连接：add_connection(const NetworkConnection& connection)
⚝ 按连接 ID 查找连接：find_connection_by_id(const std::string& id)
⚝ 按客户端 IP 地址查找连接：find_connections_by_client_ip(const std::string& clientIP)
⚝ 按服务器端口查找连接：find_connections_by_server_port(int serverPort)
⚝ 按连接状态查找连接：find_connections_by_status(const std::string& status)
⚝ 按连接时间范围查找连接（例如，查找最近一小时内的连接）：find_connections_by_time_range(std::time_t startTime, std::time_t endTime)
⚝ 更新连接状态：update_connection_status(const std::string& id, const std::string& newStatus)
⚝ 遍历所有连接（按连接 ID 排序）：print_all_connections_by_id()
⚝ 遍历所有连接（按连接时间排序）：print_all_connections_by_time()
⚝ ... 等等
6.3.3 代码详解 (Code Details)
下面实现上述设计，并给出代码示例。
① 包含头文件和命名空间：
1
#include <iostream>
2
#include <string>
3
#include <ctime>
4
#include <iomanip>
5
#include <boost/multi_index_container.hpp>
6
#include <boost/multi_index/ordered_index.hpp>
7
#include <boost/multi_index/identity.hpp>
8
#include <boost/multi_index/member.hpp>
9
10
using namespace boost::multi_index;
② NetworkConnection 结构体定义 (同 6.3.2 节)：
1
struct NetworkConnection { /* ... */ };
③ connection_container 类型定义 (同 6.3.2 节)：
1
typedef multi_index_container< /* ... */ > connection_container;
④ 添加连接函数：
1
void add_connection(connection_container& connections, const NetworkConnection& connection) {
2
connections.insert(connection);
3
}
⑤ 按连接 ID 查找连接函数：
1
connection_container::index<0>::type::iterator find_connection_by_id(connection_container& connections, const std::string& id) {
2
auto& id_index = connections.get<0>(); // 获取按连接 ID 排序的索引
3
return id_index.find(id);
4
}
⑥ 按客户端 IP 地址查找连接函数：
1
std::pair<connection_container::index<1>::type::iterator, connection_container::index<1>::type::iterator>
2
find_connections_by_client_ip(connection_container& connections, const std::string& clientIP) {
3
auto& ip_index = connections.get<1>(); // 获取按客户端 IP 排序的索引
4
return ip_index.equal_range(clientIP);
5
}
⑦ 按服务器端口查找连接函数：
1
std::pair<connection_container::index<2>::type::iterator, connection_container::index<2>::type::iterator>
2
find_connections_by_server_port(connection_container& connections, int serverPort) {
3
auto& server_port_index = connections.get<2>(); // 获取按服务器端口排序的索引
4
return server_port_index.equal_range(serverPort);
5
}
⑧ 按连接状态查找连接函数：
1
std::pair<connection_container::index<3>::type::iterator, connection_container::index<3>::type::iterator>
2
find_connections_by_status(connection_container& connections, const std::string& status) {
3
auto& status_index = connections.get<3>(); // 获取按连接状态排序的索引
4
return status_index.equal_range(status);
5
}
⑨ 按连接时间范围查找连接函数：
1
std::pair<connection_container::index<4>::type::iterator, connection_container::index<4>::type::iterator>
2
find_connections_by_time_range(connection_container& connections, std::time_t startTime, std::time_t endTime) {
3
auto& time_index = connections.get<4>(); // 获取按连接时间排序的索引
4
return time_index.range(startTime, endTime);
5
}
⑩ 更新连接状态函数：
1
bool update_connection_status(connection_container& connections, const std::string& id, const std::string& newStatus) {
2
auto it_id = find_connection_by_id(connections, id);
3
if (it_id != connections.get<0>().end()) {
4
connections.modify(it_id, [&newStatus](NetworkConnection& connection) {
5
connection.status = newStatus;
6
});
7
return true;
8
}
9
return false;
10
}
⑪ 遍历所有连接（按连接 ID 排序）函数：
1
void print_all_connections_by_id(connection_container& connections) {
2
auto& id_index = connections.get<0>(); // 获取按连接 ID 排序的索引
3
std::cout << "Connections sorted by ID:" << std::endl;
4
for (const auto& connection : id_index) {
5
std::cout << connection << std::endl;
6
}
7
}
⑫ 遍历所有连接（按连接时间排序）函数：
1
void print_all_connections_by_time(connection_container& connections) {
2
auto& time_index = connections.get<4>(); // 获取按连接时间排序的索引
3
std::cout << "Connections sorted by Connection Time:" << std::endl;
4
for (const auto& connection : time_index) {
5
std::cout << connection << std::endl;
6
}
7
}
⑬ main 函数示例：
1
int main() {
2
connection_container connections;
3
4
std::time_t now = std::time(0);
5
add_connection(connections, NetworkConnection("conn_001", "192.168.1.100", 54321, 8080, "Connected", now));
6
add_connection(connections, NetworkConnection("conn_002", "192.168.1.101", 54322, 8080, "Pending", now - 60)); // 1 分钟前
7
add_connection(connections, NetworkConnection("conn_003", "192.168.1.102", 54323, 8081, "Connected", now - 300)); // 5 分钟前
8
add_connection(connections, NetworkConnection("conn_004", "192.168.1.100", 54324, 8080, "Disconnected", now - 3600)); // 1 小时前，同 IP
9
10
std::cout << "--- Find connection by ID: conn_002 ---" << std::endl;
11
auto it_id = find_connection_by_id(connections, "conn_002");
12
if (it_id != connections.get<0>().end()) {
13
std::cout << *it_id << std::endl;
14
}
15
16
std::cout << "--- Find connections by client IP: 192.168.1.100 ---" << std::endl;
17
auto range_ip = find_connections_by_client_ip(connections, "192.168.1.100");
18
for (auto it = range_ip.first; it != range_ip.second; ++it) {
19
std::cout << *it << std::endl;
20
}
21
22
std::cout << "--- Find connections by server port: 8080 ---" << std::endl;
23
auto range_server_port = find_connections_by_server_port(connections, 8080);
24
for (auto it = range_server_port.first; it != range_server_port.second; ++it) {
25
std::cout << *it << std::endl;
26
}
27
28
std::cout << "--- Find connections by status: Connected ---" << std::endl;
29
auto range_status = find_connections_by_status(connections, "Connected");
30
for (auto it = range_status.first; it != range_status.second; ++it) {
31
std::cout << *it << std::endl;
32
}
33
34
std::cout << "--- Find connections within the last 2 minutes ---" << std::endl;
35
std::time_t two_minutes_ago = now - 120;
36
auto range_time = find_connections_by_time_range(connections, two_minutes_ago, now);
37
for (auto it = range_time.first; it != range_time.second; ++it) {
38
std::cout << *it << std::endl;
39
}
40
41
std::cout << "--- Update status of connection conn_002 to Connected ---" << std::endl;
42
update_connection_status(connections, "conn_002", "Connected");
43
it_id = find_connection_by_id(connections, "conn_002");
44
if (it_id != connections.get<0>().end()) {
45
std::cout << *it_id << std::endl; // 验证状态是否更新
46
}
47
48
std::cout << "--- All connections sorted by ID ---" << std::endl;
49
print_all_connections_by_id(connections);
50
51
std::cout << "--- All connections sorted by Connection Time ---" << std::endl;
52
print_all_connections_by_time(connections);
53
54
return 0;
55
}
这个案例展示了如何使用 Boost.MultiIndex 构建一个网络连接管理器，并实现了多维度的查询、排序和状态更新功能。通过这个案例，读者可以学习到 Boost.MultiIndex 在网络编程和服务器开发中的应用。
END_OF_CHAPTER
7. chapter 7： API 参考 (API Reference)
7.1 multi_index_container 类
multi_index_container 类是 Boost.MultiIndex 库的核心容器，它是一个符合 STL 容器概念的类模板，用于创建多索引容器。
类声明 (Class Declaration):
1
template <typename value_type, typename IndexSpecifierList>
2
class multi_index_container;
模板参数 (Template Parameters):
⚝ value_type: 容器中存储的元素类型。
⚝ IndexSpecifierList: 一个索引说明符列表，用于定义容器的索引结构。这是一个由 indexed_by 辅助类模板构建的类型列表，每个元素描述一个索引。
主要成员类型 (Main Member Types):
⚝ value_type: 元素的类型。
⚝ size_type: 用于表示大小的无符号整型。
⚝ difference_type: 用于表示元素之间距离的带符号整型。
⚝ reference: 元素的引用类型。
⚝ const_reference: 常量元素的引用类型。
⚝ pointer: 元素指针类型。
⚝ const_pointer: 常量元素指针类型。
⚝ iterator: 默认索引的迭代器类型。通常是第一个添加的索引的迭代器类型。
⚝ const_iterator: 默认索引的常量迭代器类型。
⚝ reverse_iterator: 默认索引的逆向迭代器类型。
⚝ const_reverse_iterator: 默认索引的常量逆向迭代器类型。
构造函数 (Constructors):
⚝ multi_index_container(): 默认构造函数，创建一个空的 multi_index_container。
⚝ multi_index_container(const multi_index_container& other): 拷贝构造函数。
⚝ multi_index_container(multi_index_container&& other): 移动构造函数 (C++11 起)。
⚝ multi_index_container(std::initializer_list<value_type> init): 初始化列表构造函数 (C++11 起)。
⚝ template <typename InputIterator> multi_index_container(InputIterator first, InputIterator last): 范围构造函数，使用迭代器范围 [first, last) 初始化容器。
析构函数 (Destructor):
⚝ ~multi_index_container(): 析构函数，释放容器占用的资源。
赋值运算符 (Assignment Operators):
⚝ multi_index_container& operator=(const multi_index_container& other): 拷贝赋值运算符。
⚝ multi_index_container& operator=(multi_index_container&& other): 移动赋值运算符 (C++11 起)。
⚝ multi_index_container& operator=(std::initializer_list<value_type> init): 初始化列表赋值运算符 (C++11 起)。
索引访问 (Index Access):
⚝ index<N>(): 返回对第 N 个索引的引用（从 0 开始计数）。返回类型是 nth_index<multi_index_container, N>::type&。
⚝ index(tag): 返回与标签 tag 关联的索引的引用。返回类型是 tag_index<multi_index_container, Tag>::type&。
⚝ get<IndexSpecifier>(): 根据索引说明符 IndexSpecifier 返回索引的引用。IndexSpecifier 可以是索引的序号（从 0 开始的整数）、索引的标签类型或索引的迭代器类型。
容量 (Capacity):
⚝ size(): 返回容器中元素的数量。
⚝ max_size(): 返回容器可以容纳的最大元素数量。这通常受限于系统和可用内存。
⚝ empty(): 检查容器是否为空，如果容器中没有元素则返回 true，否则返回 false。
修改器 (Modifiers):
⚝ clear(): 移除容器中的所有元素，使容器变为空。
⚝ insert(const value_type& x): 插入元素 x 的副本。返回一个 std::pair<iterator, bool>，其中 iterator 指向插入的元素（或已存在的等价元素），bool 表示是否成功插入（对于 *_unique 索引，如果元素已存在则插入失败）。
⚝ insert(value_type&& x): 移动插入元素 x (C++11 起)。返回类型与 insert(const value_type& x) 相同。
⚝ template <typename... Args> std::pair<iterator, bool> emplace(Args&&... args): 就地构造元素并插入 (C++11 起)。返回类型与 insert 相同。
⚝ template <typename InputIterator> void insert(InputIterator first, InputIterator last): 插入范围 [first, last) 内的元素。
⚝ erase(iterator pos): 移除迭代器 pos 指向的元素。返回指向被移除元素之后元素的迭代器。
⚝ erase(iterator first, iterator last): 移除范围 [first, last) 内的元素。返回指向最后一个被移除元素之后元素的迭代器。
⚝ erase(const key_type& k): 移除所有键等于 k 的元素（仅适用于有序索引和哈希索引）。返回移除的元素数量。
⚝ modify(iterator pos, const value_type& x): 修改迭代器 pos 指向的元素为 x。重要: 只能修改非键部分，修改键部分会导致容器内部索引结构失效。
⚝ modify(iterator pos, const Functor& f): 使用仿函数 f 修改迭代器 pos 指向的元素。仿函数 f 接受一个非常量引用作为参数，允许在原地修改元素。重要: 只能修改非键部分。
⚝ replace(iterator pos, const value_type& x): 替换迭代器 pos 指向的元素为 x。与 modify 类似，但语义上更强调替换整个元素（尽管实际上也只能修改非键部分）。
⚝ replace(iterator pos, const Functor& f): 使用仿函数 f 替换迭代器 pos 指向的元素。
查找 (Lookup):
⚝ find(const key_type& k): 在默认索引中查找键为 k 的元素。返回指向找到的第一个元素的迭代器，如果未找到则返回 end()。仅适用于有序索引和哈希索引。
⚝ count(const key_type& k): 在默认索引中统计键为 k 的元素数量。仅适用于有序索引和哈希索引。
⚝ lower_bound(const key_type& k): 在默认索引中查找第一个键不小于 k 的元素。返回指向该元素的迭代器，如果所有元素的键都小于 k，则返回 end()。仅适用于有序索引。
⚝ upper_bound(const key_type& k): 在默认索引中查找第一个键大于 k 的元素。返回指向该元素的迭代器，如果所有元素的键都不大于 k，则返回 end()。仅适用于有序索引。
⚝ equal_range(const key_type& k): 在默认索引中查找键等于 k 的元素的范围。返回一个 std::pair<iterator, iterator>，表示范围 [first, second)，其中 first 是指向第一个键等于 k 的元素的迭代器，second 是指向第一个键大于 k 的元素的迭代器。仅适用于有序索引。
迭代器 (Iterators):
⚝ begin(): 返回指向容器起始元素的迭代器（默认索引）。
⚝ end(): 返回指向容器末尾的迭代器（默认索引）。
⚝ rbegin(): 返回指向容器逆向起始元素的逆向迭代器（默认索引）。
⚝ rend(): 返回指向容器逆向末尾的逆向迭代器（默认索引）。
⚝ cbegin(): 返回指向容器起始元素的常量迭代器（默认索引）。 (C++11 起)
⚝ cend(): 返回指向容器末尾的常量迭代器（默认索引）。 (C++11 起)
⚝ crbegin(): 返回指向容器逆向起始元素的常量逆向迭代器（默认索引）。 (C++11 起)
⚝ crend(): 返回指向容器逆向末尾的常量逆向迭代器（默认索引）。 (C++11 起)
其他 (Miscellaneous):
⚝ swap(multi_index_container& other): 交换两个 multi_index_container 对象的内容。
⚝ get_allocator(): 返回容器的分配器对象的副本。
示例 (Example):
1
#include <boost/multi_index_container.hpp>
2
#include <boost/multi_index/ordered_index.hpp>
3
#include <boost/multi_index/identity.hpp>
4
#include <string>
5
6
using namespace boost::multi_index;
7
8
struct employee {
9
int id;
10
std::string name;
11
double salary;
12
13
employee(int id, const std::string& name, double salary) : id(id), name(name), salary(salary) {}
14
15
friend std::ostream& operator<<(std::ostream& os, const employee& emp) {
16
os << "ID: " << emp.id << ", Name: " << emp.name << ", Salary: " << emp.salary;
17
return os;
18
}
19
};
20
21
using employee_set = multi_index_container<
22
employee,
23
indexed_by<
24
ordered_unique<identity<employee>>, // index by employee id
25
ordered_non_unique<member<employee, std::string, &employee::name>> // index by employee name
26
>
27
>;
28
29
int main() {
30
employee_set employees;
31
employees.emplace(1, "Alice", 50000.0);
32
employees.emplace(2, "Bob", 60000.0);
33
employees.emplace(3, "Alice", 55000.0); // Will be inserted, name index allows non-unique
34
35
std::cout << "Size: " << employees.size() << std::endl; // Output: Size: 3
36
37
// Accessing index by ID (default index - index<0> or get<0> or get<identity<employee>>):
38
auto& id_index = employees.get<0>(); // or employees.index<0>();
39
auto it_id = id_index.find(2);
40
if (it_id != id_index.end()) {
41
std::cout << "Found by ID: " << *it_id << std::endl; // Output: Found by ID: ID: 2, Name: Bob, Salary: 60000
42
}
43
44
// Accessing index by Name (index<1> or get<1> or get<member<employee, std::string, &employee::name>>):
45
auto& name_index = employees.get<1>(); // or employees.index<1>();
46
auto range_name = name_index.equal_range("Alice");
47
std::cout << "Employees named Alice:" << std::endl;
48
for (auto it_name = range_name.first; it_name != range_name.second; ++it_name) {
49
std::cout << *it_name << std::endl;
50
// Output:
51
// ID: 1, Name: Alice, Salary: 50000
52
// ID: 3, Name: Alice, Salary: 55000
53
}
54
55
return 0;
56
}
7.2 索引类型 (Index Types) 类
Boost.MultiIndex 提供了多种索引类型，每种索引类型都提供了不同的排序和查找特性。以下是主要的索引类型类：
⚝ ordered_unique<KeyFromValue, Compare, Allocator>： 有序唯一索引。基于键的有序排列，保证键的唯一性。
▮▮▮▮⚝ KeyFromValue: 键提取器，用于从容器元素中提取键。
▮▮▮▮⚝ Compare: 比较函数对象，用于定义键的排序规则。默认为 std::less。
▮▮▮▮⚝ Allocator: 分配器类型。
⚝ ordered_non_unique<KeyFromValue, Compare, Allocator>： 有序非唯一索引。基于键的有序排列，允许键的重复。
▮▮▮▮⚝ 参数与 ordered_unique 相同。
⚝ hashed_unique<KeyFromValue, Hash, Pred, Allocator>： 哈希唯一索引。基于哈希表的索引，提供快速查找，保证键的唯一性。
▮▮▮▮⚝ KeyFromValue: 键提取器。
▮▮▮▮⚝ Hash: 哈希函数对象，用于计算键的哈希值。默认为 boost::hash。
▮▮▮▮⚝ Pred: 相等谓词，用于比较键是否相等。默认为 std::equal_to。
▮▮▮▮⚝ Allocator: 分配器类型。
⚝ hashed_non_unique<KeyFromValue, Hash, Pred, Allocator>： 哈希非唯一索引。基于哈希表的索引，提供快速查找，允许键的重复。
▮▮▮▮⚝ 参数与 hashed_unique 相同。
⚝ sequenced<Allocator>： 序列索引。维护元素插入顺序的索引，类似于 std::list 或 std::vector 的顺序。
▮▮▮▮⚝ Allocator: 分配器类型。
⚝ random_access<Allocator>： 随机访问索引。提供通过索引下标进行快速随机访问的能力，类似于 std::vector。
▮▮▮▮⚝ Allocator: 分配器类型。
通用成员函数 (Common Member Functions for Index Classes):
所有索引类型都提供类似 STL 容器的接口，包括：
⚝ 迭代器 (Iterators): begin(), end(), cbegin(), cend(), rbegin(), rend(), crbegin(), crend().
⚝ 容量 (Capacity): size(), empty(), max_size().
⚝ 查找 (Lookup): find(), count(), lower_bound() (有序索引), upper_bound() (有序索引), equal_range() (有序索引).
⚝ 修改器 (Modifiers): insert(), emplace(), erase(), clear(), modify(), replace().
访问索引 (Accessing Indices):
通过 multi_index_container 对象的 index<N>(), index(tag), 或 get<IndexSpecifier>() 成员函数可以获取对特定索引的引用，然后可以像操作普通容器一样操作这些索引。
示例 (Example - Index Types):
1
#include <boost/multi_index_container.hpp>
2
#include <boost/multi_index/ordered_index.hpp>
3
#include <boost/multi_index/hashed_index.hpp>
4
#include <boost/multi_index/sequenced_index.hpp>
5
#include <boost/multi_index/random_access_index.hpp>
6
#include <boost/multi_index/identity.hpp>
7
#include <string>
8
9
using namespace boost::multi_index;
10
11
struct data_item {
12
int id;
13
std::string name;
14
int value;
15
16
data_item(int id, const std::string& name, int value) : id(id), name(name), value(value) {}
17
};
18
19
using data_container = multi_index_container<
20
data_item,
21
indexed_by<
22
ordered_unique<identity<data_item>>, // Index by ID (ordered unique)
23
hashed_non_unique<member<data_item, std::string, &data_item::name>>, // Index by name (hashed non-unique)
24
sequenced<> // Sequenced index (insertion order)
25
// random_access<> // Random access index (numerical index) - optional, can be added
26
>
27
>;
28
29
int main() {
30
data_container items;
31
items.emplace(1, "ItemA", 10);
32
items.emplace(2, "ItemB", 20);
33
items.emplace(3, "ItemA", 30);
34
35
// Accessing ordered index by ID
36
auto& id_index = items.get<0>();
37
std::cout << "Ordered Index (by ID):" << std::endl;
38
for (const auto& item : id_index) {
39
std::cout << item.id << " "; // Output: 1 2 3
40
}
41
std::cout << std::endl;
42
43
// Accessing hashed index by name
44
auto& name_index = items.get<1>();
45
std::cout << "Hashed Index (by Name):" << std::endl;
46
for (const auto& item : name_index) {
47
std::cout << item.name << " "; // Output: ItemA ItemA ItemB (order may vary in hash index)
48
}
49
std::cout << std::endl;
50
51
// Accessing sequenced index (insertion order)
52
auto& seq_index = items.get<2>();
53
std::cout << "Sequenced Index (insertion order):" << std::endl;
54
for (const auto& item : seq_index) {
55
std::cout << item.id << " "; // Output: 1 2 3
56
}
57
std::cout << std::endl;
58
59
return 0;
60
}
7.3 键提取器 (Key Extractors) 相关类和函数
键提取器 (Key Extractors) 用于从容器的元素中提取索引键。Boost.MultiIndex 提供了多种预定义的键提取器，并允许用户自定义键提取器。
预定义的键提取器 (Predefined Key Extractors):
⚝ identity<Value>: 恒等键提取器。直接使用元素自身作为键。适用于元素类型本身就可以作为键的情况。
▮▮▮▮⚝ Value: 元素类型。
⚝ member<Value, MemberType, MemberPtr>: 成员指针键提取器。使用指向成员的指针从元素中提取键。
▮▮▮▮⚝ Value: 元素类型。
▮▮▮▮⚝ MemberType: 成员的类型。
▮▮▮▮⚝ MemberPtr: 指向成员的指针，例如 &MyClass::my_member。
⚝ global_fun<Value, KeyType, FunctionPtr>: 全局函数键提取器。使用全局函数从元素中提取键。
▮▮▮▮⚝ Value: 元素类型。
▮▮▮▮⚝ KeyType: 键的类型。
▮▮▮▮⚝ FunctionPtr: 指向全局函数的指针，函数签名应为 KeyType FunctionPtr(const Value&)。
⚝ const_mem_fun<Value, KeyType, MemFunPtr>: 常量成员函数指针键提取器。使用指向常量成员函数的指针从元素中提取键。
▮▮▮▮⚝ Value: 元素类型。
▮▮▮▮⚝ KeyType: 键的类型。
▮▮▮▮⚝ MemFunPtr: 指向常量成员函数的指针，函数签名应为 KeyType MemFunPtr(void) const。
⚝ mem_fun<Value, KeyType, MemFunPtr>: 成员函数指针键提取器。使用指向非常量成员函数的指针从元素中提取键。
▮▮▮▮⚝ Value: 元素类型。
▮▮▮▮⚝ KeyType: 键的类型。
▮▮▮▮⚝ MemFunPtr: 指向非常量成员函数的指针，函数签名应为 KeyType MemFunPtr(void)。
⚝ composite_key<Value, ComponentSpecifierList>: 复合键提取器。使用多个键提取器组合成一个复合键。
▮▮▮▮⚝ Value: 元素类型。
▮▮▮▮⚝ ComponentSpecifierList: 一个键提取器列表，用于定义复合键的各个组成部分。
自定义键提取器 (Custom Key Extractors):
用户可以自定义键提取器，只需提供一个函数对象 (仿函数或 lambda 表达式)，该函数对象接受容器元素作为参数，并返回键值。
示例 (Example - Key Extractors):
1
#include <boost/multi_index_container.hpp>
2
#include <boost/multi_index/ordered_index.hpp>
3
#include <boost/multi_index/member.hpp>
4
#include <boost/multi_index/global_fun.hpp>
5
#include <boost/multi_index/composite_key.hpp>
6
#include <string>
7
8
using namespace boost::multi_index;
9
10
struct book {
11
int id;
12
std::string title;
13
std::string author;
14
int publication_year;
15
16
book(int id, const std::string& title, const std::string& author, int year)
17
: id(id), title(title), author(author), publication_year(year) {}
18
};
19
20
// Global function key extractor
21
std::string get_author_title(const book& bk) {
22
return bk.author + " - " + bk.title;
23
}
24
25
struct get_book_id_plus_year { // Functor key extractor
26
int operator()(const book& bk) const {
27
return bk.id + bk.publication_year;
28
}
29
};
30
31
32
using book_set = multi_index_container<
33
book,
34
indexed_by<
35
ordered_unique<member<book, int, &book::id>>, // Index by book ID (member pointer)
36
ordered_non_unique<global_fun<book, std::string, get_author_title>>, // Index by author and title (global function)
37
ordered_non_unique<composite_key<book,
38
member<book, std::string, &book::author>,
39
member<book, int, &book::publication_year>
40
>>, // Composite key: author + publication year
41
ordered_non_unique<
42
boost::multi_index::key<&get_book_id_plus_year, book> // Functor key extractor (lambda also works)
43
>
44
>
45
>;
46
47
48
int main() {
49
book_set books;
50
books.emplace(1, "The Lord of the Rings", "J.R.R. Tolkien", 1954);
51
books.emplace(2, "Pride and Prejudice", "Jane Austen", 1813);
52
books.emplace(3, "The Hobbit", "J.R.R. Tolkien", 1937);
53
54
// Index by ID
55
auto& id_index = books.get<0>();
56
std::cout << "Books by ID:" << std::endl;
57
for (const auto& bk : id_index) {
58
std::cout << bk.id << " "; // Output: 1 2 3
59
}
60
std::cout << std::endl;
61
62
// Index by author and title (global function)
63
auto& author_title_index = books.get<1>();
64
std::cout << "Books by Author and Title:" << std::endl;
65
for (const auto& bk : author_title_index) {
66
std::cout << get_author_title(bk) << " "; // Output: Jane Austen - Pride and Prejudice J.R.R. Tolkien - The Hobbit J.R.R. Tolkien - The Lord of the Rings
67
}
68
std::cout << std::endl;
69
70
// Index by composite key (author + year)
71
auto& composite_index = books.get<2>();
72
std::cout << "Books by Composite Key (Author + Year):" << std::endl;
73
for (const auto& bk : composite_index) {
74
std::cout << bk.author << " (" << bk.publication_year << ") "; // Output: Jane Austen (1813) J.R.R. Tolkien (1937) J.R.R. Tolkien (1954)
75
}
76
std::cout << std::endl;
77
78
// Index by functor key
79
auto& functor_index = books.get<3>();
80
std::cout << "Books by Functor Key (ID + Year):" << std::endl;
81
for (const auto& bk : functor_index) {
82
std::cout << get_book_id_plus_year()(bk) << " "; // Output: 1955 1815 1940
83
}
84
std::cout << std::endl;
85
86
87
return 0;
88
}
7.4 迭代器 (Iterators) 相关类型
Boost.MultiIndex 的每个索引都提供了自己的迭代器类型，用于遍历该索引中的元素。迭代器类型与 STL 迭代器概念兼容。
主要的迭代器类型 (Main Iterator Types):
⚝ iterator: 指向元素的非常量迭代器。允许修改迭代器指向的元素（注意: 只能修改非键部分）。
⚝ const_iterator: 指向元素的常量迭代器。不允许修改迭代器指向的元素。
⚝ reverse_iterator: 逆向非常量迭代器。
⚝ const_reverse_iterator: 逆向常量迭代器。
获取迭代器 (Obtaining Iterators):
可以通过以下成员函数从 multi_index_container 对象或其索引对象获取迭代器：
⚝ begin(): 返回指向容器或索引起始元素的迭代器。
⚝ end(): 返回指向容器或索引末尾的迭代器（past-the-end）。
⚝ cbegin(): 返回指向容器或索引起始元素的常量迭代器 (C++11 起)。
⚝ cend(): 返回指向容器或索引末尾的常量迭代器 (C++11 起)。
⚝ rbegin(): 返回指向容器或索引逆向起始元素的逆向迭代器。
⚝ rend(): 返回指向容器或索引逆向末尾的逆向迭代器。
⚝ crbegin(): 返回指向容器或索引逆向起始元素的常量逆向迭代器 (C++11 起)。
⚝ crend(): 返回指向容器或索引逆向末尾的常量逆向迭代器 (C++11 起)。
迭代器操作 (Iterator Operations):
MultiIndex 迭代器支持标准的迭代器操作，包括：
⚝ 解引用 (*it, it->member): 访问迭代器指向的元素。
⚝ 递增 (++it, it++): 移动到下一个元素。
⚝ 递减 (--it, it--): 移动到前一个元素 (双向迭代器)。
⚝ 比较 (it1 == it2, it1 != it2): 比较两个迭代器是否指向相同位置。
⚝ 距离计算 (std::distance(it1, it2)): 计算两个迭代器之间的距离 (随机访问迭代器)。
⚝ 迭代器算术 (it + n, it - n, it += n, it -= n): 迭代器算术运算 (随机访问迭代器)。
示例 (Example - Iterators):
1
#include <boost/multi_index_container.hpp>
2
#include <boost/multi_index/ordered_index.hpp>
3
#include <boost/multi_index/identity.hpp>
4
#include <string>
5
#include <iostream>
6
#include <algorithm>
7
8
using namespace boost::multi_index;
9
10
struct product {
11
int id;
12
std::string name;
13
double price;
14
15
product(int id, const std::string& name, double price) : id(id), name(name), price(price) {}
16
17
friend std::ostream& operator<<(std::ostream& os, const product& prod) {
18
os << "ID: " << prod.id << ", Name: " << prod.name << ", Price: " << prod.price;
19
return os;
20
}
21
};
22
23
using product_set = multi_index_container<
24
product,
25
indexed_by<
26
ordered_unique<identity<product>> // Index by product ID
27
>
28
>;
29
30
int main() {
31
product_set products;
32
products.emplace(101, "Laptop", 1200.0);
33
products.emplace(102, "Mouse", 25.0);
34
products.emplace(103, "Keyboard", 75.0);
35
36
// Using iterators to traverse the container (default index)
37
std::cout << "Iterating through products:" << std::endl;
38
for (auto it = products.begin(); it != products.end(); ++it) {
39
std::cout << *it << std::endl;
40
}
41
42
// Using range-based for loop (C++11)
43
std::cout << "\nRange-based for loop:" << std::endl;
44
for (const auto& prod : products) {
45
std::cout << prod << std::endl;
46
}
47
48
// Using reverse iterators
49
std::cout << "\nReverse iteration:" << std::endl;
50
for (auto rit = products.rbegin(); rit != products.rend(); ++rit) {
51
std::cout << *rit << std::endl;
52
}
53
54
// Using const iterators
55
std::cout << "\nConst iteration:" << std::endl;
56
for (auto cit = products.cbegin(); cit != products.cend(); ++cit) {
57
std::cout << *cit << std::endl;
58
}
59
60
return 0;
61
}
7.5 算法 (Algorithms) 支持
Boost.MultiIndex 容器的索引提供了与 STL 容器类似的迭代器接口，因此可以与许多 STL 算法一起使用。
兼容的算法 (Compatible Algorithms):
大多数接受迭代器范围的 STL 算法都可以与 MultiIndex 容器的索引一起使用，例如：
⚝ 查找算法 (Searching Algorithms): std::find, std::find_if, std::find_if_not, std::binary_search (有序索引), std::count, std::count_if.
⚝ 遍历算法 (Traversal Algorithms): std::for_each, std::transform.
⚝ 复制和移动算法 (Copying and Moving Algorithms): std::copy, std::copy_if, std::move, std::copy_n, std::move_n.
⚝ 修改算法 (Modifying Algorithms - limited): 部分修改算法可以用于非键部分，例如 std::replace_if, std::transform (用于修改非键成员). 注意: 直接修改键部分会导致容器内部索引结构失效，应使用 modify 或 replace 成员函数。
⚝ 数值算法 (Numeric Algorithms): std::accumulate, std::inner_product, std::adjacent_difference, std::partial_sum.
⚝ 关系算法 (Relational Algorithms): std::equal, std::mismatch.
⚝ 排序算法 (Sorting Algorithms - not directly applicable): 排序算法不直接适用于 MultiIndex 容器，因为容器本身维护了索引顺序。如果需要对 MultiIndex 容器的内容进行排序，通常是基于已有的索引顺序进行遍历或复制到其他可排序的容器中。
注意事项 (Considerations):
⚝ 键的不可变性 (Key Immutability): 在使用算法时，要特别注意不要直接修改元素的键部分。如果需要修改键，必须使用 multi_index_container 提供的 modify 或 replace 成员函数，以确保索引结构得到正确维护。
⚝ 算法的适用性 (Algorithm Suitability): 并非所有 STL 算法都对 MultiIndex 容器有意义。例如，排序算法对于有序索引来说是冗余的，而对于哈希索引则不适用。
⚝ 性能考量 (Performance Considerations): 算法的性能取决于所使用的索引类型。例如，在有序索引上使用 std::binary_search 会非常高效，而在哈希索引上则可能不如直接使用 find 成员函数。
示例 (Example - Algorithms):
1
#include <boost/multi_index_container.hpp>
2
#include <boost/multi_index/ordered_index.hpp>
3
#include <boost/multi_index/identity.hpp>
4
#include <string>
5
#include <vector>
6
#include <algorithm>
7
#include <iostream>
8
#include <numeric>
9
10
using namespace boost::multi_index;
11
12
struct product_alg {
13
int id;
14
std::string name;
15
double price;
16
bool in_stock;
17
18
product_alg(int id, const std::string& name, double price, bool stock)
19
: id(id), name(name), price(price), in_stock(stock) {}
20
21
friend std::ostream& operator<<(std::ostream& os, const product_alg& prod) {
22
os << "ID: " << prod.id << ", Name: " << prod.name << ", Price: " << prod.price << ", In Stock: " << (prod.in_stock ? "Yes" : "No");
23
return os;
24
}
25
};
26
27
using product_alg_set = multi_index_container<
28
product_alg,
29
indexed_by<
30
ordered_unique<identity<product_alg>> // Index by product ID
31
>
32
>;
33
34
int main() {
35
product_alg_set products;
36
products.emplace(201, "Monitor", 300.0, true);
37
products.emplace(202, "Webcam", 50.0, false);
38
products.emplace(203, "Speaker", 100.0, true);
39
products.emplace(204, "Headphones", 150.0, false);
40
41
// Using std::find_if to find a product not in stock
42
auto not_in_stock_it = std::find_if(products.begin(), products.end(),
43
[](const product_alg& p){ return !p.in_stock; });
44
if (not_in_stock_it != products.end()) {
45
std::cout << "Product not in stock found: " << *not_in_stock_it << std::endl;
46
// Output: Product not in stock found: ID: 202, Name: Webcam, Price: 50, In Stock: No
47
}
48
49
// Using std::count_if to count products in stock
50
int in_stock_count = std::count_if(products.begin(), products.end(),
51
[](const product_alg& p){ return p.in_stock; });
52
std::cout << "Number of products in stock: " << in_stock_count << std::endl; // Output: Number of products in stock: 2
53
54
// Using std::transform to collect product names into a vector
55
std::vector<std::string> product_names;
56
std::transform(products.begin(), products.end(), std::back_inserter(product_names),
57
[](const product_alg& p){ return p.name; });
58
std::cout << "Product names: ";
59
for (const auto& name : product_names) {
60
std::cout << name << " "; // Output: Product names: Headphones Monitor Speaker Webcam
61
}
62
std::cout << std::endl;
63
64
// Using std::accumulate to calculate total price of all products (illustrative, might not be practical)
65
double total_price = std::accumulate(products.begin(), products.end(), 0.0,
66
[](double sum, const product_alg& p){ return sum + p.price; });
67
std::cout << "Total price of all products: $" << total_price << std::endl; // Output: Total price of all products: $600
68
69
return 0;
70
}
END_OF_CHAPTER
8. chapter 8： 最佳实践与常见问题 (Best Practices and Common Issues)
8.1 最佳实践 (Best Practices)
8.1.1 清晰地定义索引需求 (Clearly Define Index Requirements)
在开始使用 Boost.MultiIndex 之前，至关重要的是清晰地定义索引需求 (Clearly Define Index Requirements)。这意味着你需要深入理解你的数据结构需要支持哪些类型的查询和操作。不明确的需求会导致索引设计的不足或者过度设计，从而影响性能和代码的可维护性。
① 理解数据访问模式 (Understand Data Access Patterns)：
在设计 Multi-index 容器之前，仔细分析你的应用场景中数据是如何被访问和操作的。
▮▮▮▮ⓐ 查询类型 (Query Types)：你需要根据哪些字段进行查找？是单一字段的精确匹配，还是多字段的范围查询？例如，在一个学生信息管理系统中，你可能需要根据学号（唯一）、姓名、班级、成绩等进行查询。
▮▮▮▮ⓑ 排序需求 (Sorting Requirements)：数据需要按照哪些字段排序？不同的索引可以提供不同的排序方式。例如，你可能需要按学生姓名排序，也可能需要按成绩排序。
▮▮▮▮ⓒ 修改频率 (Modification Frequency)：数据是否频繁更新？某些索引类型在插入和删除操作上可能比其他类型更高效。如果数据更新频繁，需要考虑索引的维护成本。
④ 确定索引类型 (Determine Index Types)：
基于数据访问模式，选择合适的索引类型。
▮▮▮▮ⓐ 唯一性约束 (Uniqueness Constraints)：是否需要保证某些字段的唯一性？例如，学号应该是唯一的，可以使用 ordered_unique 或 hashed_unique 索引。
▮▮▮▮ⓑ 查找效率 (Search Efficiency)：对于频繁的查找操作，选择查找效率高的索引类型。hashed_unique 和 hashed_non_unique 提供平均常数时间的查找效率，而 ordered_unique 和 ordered_non_unique 提供对数时间的查找效率。
▮▮▮▮ⓒ 排序需求 (Ordering Requirements)：如果需要按特定顺序遍历元素，ordered_indices 是最佳选择。sequenced_indices 适用于需要维护插入顺序的场景。
④ 考虑性能和内存 (Consider Performance and Memory)：
不同的索引类型在性能和内存占用上有所不同。
▮▮▮▮ⓐ 查找性能 (Search Performance)：哈希索引通常提供更快的查找速度，但依赖于良好的哈希函数。有序索引在范围查询和排序方面更有效。
▮▮▮▮ⓑ 插入和删除性能 (Insertion and Deletion Performance)：某些索引类型在插入和删除操作上可能更慢，特别是当容器很大时。
▮▮▮▮ⓒ 内存占用 (Memory Footprint)：每个索引都会增加内存占用。过多的索引会显著增加内存消耗。只创建必要的索引，避免过度设计。
清晰地定义索引需求是使用 Boost.MultiIndex 的第一步，也是最关键的一步。它直接影响到后续索引类型的选择、键提取器的设计以及容器的整体性能。在项目初期投入时间进行需求分析，可以避免后续很多潜在的问题，并确保你的 Multi-index 容器能够高效、稳定地运行。
8.1.2 选择合适的索引类型 (Choose Appropriate Index Types)
Boost.MultiIndex 提供了多种索引类型，每种类型都有其特定的适用场景和性能特点。选择合适的索引类型 (Choose Appropriate Index Types) 对于充分利用 Boost.MultiIndex 的优势至关重要。错误的选择可能导致性能下降，甚至功能无法实现。
① 有序索引 (Ordered Indices)：
ordered_unique 和 ordered_non_unique 索引基于键的排序来组织元素。
▮▮▮▮ⓐ 适用场景 (Use Cases)：
⚝ 需要按特定顺序遍历元素。
⚝ 需要范围查询，例如查找某个范围内的数据。
⚝ 需要查找最小值、最大值等。
▮▮▮▮ⓑ 性能特点 (Performance Characteristics)：
⚝ 查找、插入、删除操作的时间复杂度为 \(O(\log N)\)，其中 \(N\) 是容器中元素的数量。
⚝ 支持高效的范围查询和排序操作。
⚝ 内存占用相对较高，因为需要维护排序结构（通常是红黑树）。
▮▮▮▮ⓒ 选择建议 (Selection Advice)：
⚝ 当需要排序功能或者范围查询时，优先选择有序索引。
⚝ 如果键需要唯一，使用 ordered_unique；否则使用 ordered_non_unique。
② 哈希索引 (Hashed Indices)：
hashed_unique 和 hashed_non_unique 索引使用哈希表来组织元素。
▮▮▮▮ⓐ 适用场景 (Use Cases)：
⚝ 需要快速查找特定键的元素。
⚝ 不需要排序功能或范围查询。
▮▮▮▮ⓑ 性能特点 (Performance Characteristics)：
⚝ 平均情况下，查找、插入、删除操作的时间复杂度为 \(O(1)\)。最坏情况下为 \(O(N)\)，但这种情况很少发生，尤其是在哈希函数设计良好的情况下。
⚝ 查找速度非常快，尤其是在数据量较大时。
⚝ 不支持范围查询和排序操作。
⚝ 内存占用取决于哈希表的大小和负载因子。
▮▮▮▮ⓒ 选择建议 (Selection Advice)：
⚝ 当主要需求是快速查找，并且不需要排序或范围查询时，优先选择哈希索引。
⚝ 如果键需要唯一，使用 hashed_unique；否则使用 hashed_non_unique。
⚝ 注意选择合适的哈希函数，以避免哈希冲突，提高性能。
③ 序列索引 (Sequenced Indices)：
sequenced 索引维护元素的插入顺序，类似于 std::list。
▮▮▮▮ⓐ 适用场景 (Use Cases)：
⚝ 需要按插入顺序遍历元素。
⚝ 需要支持在容器的头部和尾部快速插入和删除元素。
⚝ 实现 FIFO 队列或 LIFO 栈等数据结构。
▮▮▮▮ⓑ 性能特点 (Performance Characteristics)：
⚝ 在头部和尾部插入和删除元素的时间复杂度为 \(O(1)\)。
⚝ 按位置访问元素的时间复杂度为 \(O(N)\)。
⚝ 不支持按键查找或排序。
⚝ 内存占用与元素数量成线性关系。
▮▮▮▮ⓒ 选择建议 (Selection Advice)：
⚝ 当需要维护插入顺序，并且主要操作是在头部和尾部进行时，选择序列索引。
⚝ 不适用于需要按键查找或排序的场景。
④ 随机访问索引 (Random Access Indices)：
random_access 索引允许通过索引位置快速访问元素，类似于 std::vector。
▮▮▮▮ⓐ 适用场景 (Use Cases)：
⚝ 需要通过索引位置快速访问元素。
⚝ 需要支持随机访问迭代器。
▮▮▮▮ⓑ 性能特点 (Performance Characteristics)：
⚝ 通过索引位置访问元素的时间复杂度为 \(O(1)\)。
⚝ 在尾部插入和删除元素的时间复杂度为 \(O(1)\)。在中间插入和删除元素的时间复杂度为 \(O(N)\)。
⚝ 不支持按键查找或排序。
⚝ 内存占用与元素数量成线性关系，可能存在预分配内存的情况。
▮▮▮▮ⓒ 选择建议 (Selection Advice)：
⚝ 当需要通过索引位置快速访问元素，并且主要操作是在尾部进行时，选择随机访问索引。
⚝ 不适用于需要按键查找或排序的场景。
⑤ 组合使用 (Combination)：
在实际应用中，通常需要组合使用 (Combination) 多种索引类型来满足不同的查询和操作需求。例如，在一个学生信息管理系统中，你可能需要：
⚝ 使用 ordered_unique 索引按学号查找学生（唯一性、排序）。
⚝ 使用 ordered_non_unique 索引按班级和姓名查找学生（排序、范围查询）。
⚝ 使用 hashed_non_unique 索引按姓名快速查找学生（快速查找）。
合理组合索引类型，可以充分发挥 Boost.MultiIndex 的灵活性和高效性。在设计 Multi-index 容器时，仔细评估每种索引类型的特点，并根据实际需求进行选择和组合，是获得最佳性能的关键。
8.1.3 高效的键提取器 (Efficient Key Extractors)
键提取器 (Key Extractors) 在 Boost.MultiIndex 中扮演着至关重要的角色。它们负责从容器中的元素中提取索引键，索引的效率直接依赖于键提取器的效率。高效的键提取器 (Efficient Key Extractors) 可以显著提升 Multi-index 容器的性能。
① 避免不必要的拷贝 (Avoid Unnecessary Copies)：
键提取器应该尽可能避免不必要的拷贝操作，尤其是在键类型是复杂对象或者字符串时。
▮▮▮▮ⓐ 使用引用 (Use References)：如果键类型是对象或字符串，键提取器应该返回键的引用或常量引用，而不是拷贝。例如，使用 boost::multi_index::member 提取成员变量时，默认返回的是引用。
▮▮▮▮ⓑ 避免在键提取器中进行复杂计算 (Avoid Complex Calculations in Key Extractors)：键提取器应该尽可能简单快速。避免在键提取器中进行复杂的计算或数据转换。如果需要进行复杂计算，最好在插入元素之前完成，并将计算结果作为键存储在元素中。
② 选择合适的键提取器类型 (Choose the Right Key Extractor Type)：
Boost.MultiIndex 提供了多种键提取器，根据不同的场景选择合适的类型可以提高代码的可读性和性能。
▮▮▮▮ⓐ 成员指针键提取器 (member)：当键是元素类的成员变量时，member 是最直接和高效的选择。它直接通过成员指针访问成员变量，避免了额外的函数调用开销。
1
struct Student {
2
int id;
3
std::string name;
4
// ...
5
};
6
7
using StudentContainer = multi_index_container<
8
Student,
9
indexed_by<
10
ordered_unique<member<Student, int, &Student::id>>, // 使用 member 提取 id
11
ordered_non_unique<member<Student, std::string, &Student::name>> // 使用 member 提取 name
12
>
13
>;
▮▮▮▮ⓑ 全局函数键提取器 (global_fun)：当键的提取逻辑比较复杂，或者需要从非成员函数中提取键时，可以使用 global_fun。但需要注意，全局函数调用会带来一定的开销。
1
struct Book {
2
std::string title;
3
std::string author;
4
// ...
5
};
6
7
std::string get_author_last_name(const Book& book) {
8
// 提取作者姓氏的逻辑
9
std::string last_name = /* ... */;
10
return last_name;
11
}
12
13
using BookContainer = multi_index_container<
14
Book,
15
indexed_by<
16
ordered_non_unique<global_fun<Book, std::string, get_author_last_name>> // 使用 global_fun 提取作者姓氏
17
>
18
>;
▮▮▮▮ⓒ 仿函数键提取器 (const_mem_fun, mem_fun)：当键的提取逻辑封装在元素类的成员函数中时，可以使用 const_mem_fun（const 成员函数）或 mem_fun（非 const 成员函数）。
1
struct Product {
2
double price;
3
double get_discounted_price() const {
4
// 计算折扣价格的逻辑
5
return price * 0.9;
6
}
7
// ...
8
};
9
10
using ProductContainer = multi_index_container<
11
Product,
12
indexed_by<
13
ordered_non_unique<const_mem_fun<Product, double, &Product::get_discounted_price>> // 使用 const_mem_fun 提取折扣价格
14
>
15
>;
▮▮▮▮ⓓ Lambda 表达式键提取器 (Lambda Expression Key Extractor)：对于简单的键提取逻辑，或者在需要内联键提取器时，Lambda 表达式是一种简洁高效的选择。Lambda 表达式可以避免函数调用开销，并且可以方便地捕获上下文变量。
1
struct Event {
2
std::time_t timestamp;
3
std::string description;
4
// ...
5
};
6
7
using EventContainer = multi_index_container<
8
Event,
9
indexed_by<
10
ordered_non_unique<
11
tag<timestamp>,
12
// 使用 Lambda 表达式提取时间戳
13
[](const Event& event){ return event.timestamp; }
14
>,
15
ordered_non_unique<
16
tag<description>,
17
// 使用 Lambda 表达式提取描述
18
[](const Event& event){ return event.description; }
19
>
20
>
21
>;
③ 复合键的优化 (Optimization of Composite Keys)：
当使用 composite_key 创建复合键时，需要注意键提取器的顺序和效率。
▮▮▮▮ⓐ 键的顺序 (Order of Keys)：在 composite_key 中，键的顺序会影响排序和查找效率。将最常用的键放在前面，可以提高查询效率。
▮▮▮▮ⓑ 避免重复计算 (Avoid Redundant Calculations)：如果复合键中的某些键提取器需要进行复杂的计算，确保这些计算不会被重复执行。可以考虑将计算结果缓存起来，或者在元素类中预先计算好。
选择高效的键提取器是优化 Boost.MultiIndex 性能的关键步骤之一。通过避免不必要的拷贝、选择合适的键提取器类型以及优化复合键的设计，可以显著提升 Multi-index 容器的效率，使其在各种应用场景中都能发挥出最佳性能。
8.2 常见问题与解答 (Common Issues and Solutions)
在使用 Boost.MultiIndex 的过程中，开发者可能会遇到各种常见问题 (Common Issues)。了解这些问题及其解答 (Solutions) 可以帮助开发者更快速地解决问题，提高开发效率。
8.2.1 编译错误 (Compilation Errors)
编译错误是使用 C++ 库时最常见的问题之一。Boost.MultiIndex 由于其模板元编程的特性，编译错误信息有时可能比较复杂。
① 模板实例化错误 (Template Instantiation Errors)：
由于 Boost.MultiIndex 是一个高度模板化的库，模板实例化错误是最常见的编译错误类型。
▮▮▮▮ⓐ 错误信息解读 (Error Message Interpretation)：仔细阅读编译器的错误信息，通常错误信息会指出错误的模板实例化位置以及相关的类型不匹配问题。
▮▮▮▮ⓑ 常见原因 (Common Causes)：
⚝ 类型不匹配 (Type Mismatch)：定义 Multi-index 容器时，使用的类型与实际元素类型不符，或者键提取器返回的类型与索引类型要求的类型不符。
⚝ 缺少必要的头文件 (Missing Header Files)：忘记包含 Boost.MultiIndex 相关的头文件，例如 <boost/multi_index_container.hpp>，<boost/multi_index/ordered_index.hpp> 等。
⚝ 使用了未定义的类型 (Undefined Types)：在定义 Multi-index 容器时，使用了尚未定义的类型。确保所有类型在使用前都已定义。
▮▮▮▮ⓒ 解决方法 (Solutions)：
⚝ 检查类型定义 (Check Type Definitions)：仔细检查 Multi-index 容器的定义，确保所有类型都正确匹配，包括元素类型、键类型、比较函数类型等。
⚝ 包含必要的头文件 (Include Necessary Header Files)：确保包含了所有 Boost.MultiIndex 相关的头文件。
⚝ 逐步简化代码 (Simplify Code Gradually)：如果错误信息过于复杂，可以逐步简化 Multi-index 容器的定义，例如先只定义一个最简单的索引，逐步添加其他索引，以便更容易定位错误。
⚝ 使用静态断言 (Use Static Assertions)：在关键位置使用 static_assert 检查类型是否符合预期，例如检查键提取器返回的类型是否与索引类型要求的类型一致。
② SFINAE (Substitution Failure Is Not An Error) 相关错误：
Boost.MultiIndex 内部大量使用了 SFINAE 技术，有时编译错误可能与 SFINAE 相关。
▮▮▮▮ⓐ 错误信息解读 (Error Message Interpretation)：SFINAE 相关的错误信息通常比较晦涩，可能涉及到模板替换失败、函数重载决议失败等。
▮▮▮▮ⓑ 常见原因 (Common Causes)：
⚝ 约束不满足 (Constraint Not Satisfied)：某些 Boost.MultiIndex 的组件有类型约束，例如要求键类型必须是可拷贝构造的、可比较的等。如果类型不满足这些约束，就会导致 SFINAE 错误。
⚝ 模板参数推导失败 (Template Argument Deduction Failure)：在某些情况下，编译器可能无法正确推导出模板参数，导致 SFINAE 错误。
▮▮▮▮ⓒ 解决方法 (Solutions)：
⚝ 检查类型约束 (Check Type Constraints)：仔细阅读 Boost.MultiIndex 的文档，了解各个组件的类型约束，确保使用的类型满足这些约束。
⚝ 显式指定模板参数 (Explicitly Specify Template Arguments)：在某些情况下，可以尝试显式指定模板参数，帮助编译器进行模板参数推导。
⚝ 简化模板表达式 (Simplify Template Expressions)：如果模板表达式过于复杂，可以尝试简化表达式，或者将复杂逻辑拆分成多个简单的步骤。
③ 链接错误 (Linker Errors)：
虽然 Boost.MultiIndex 主要是头文件库，但在某些情况下，也可能出现链接错误。
▮▮▮▮ⓐ 错误信息解读 (Error Message Interpretation)：链接错误通常指示链接器找不到某些符号的定义，例如未定义的函数或变量。
▮▮▮▮ⓑ 常见原因 (Common Causes)：
⚝ Boost 库未正确链接 (Boost Library Not Linked Correctly)：如果使用了需要链接的 Boost 组件（虽然 Multi-index 本身是头文件库，但其依赖的 Boost.Config 等库可能是需要链接的），需要确保 Boost 库已正确链接到项目中。
⚝ 编译单元不完整 (Incomplete Compilation Units)：在大型项目中，可能存在编译单元编译不完整的情况，导致某些符号未被正确编译和链接。
▮▮▮▮ⓒ 解决方法 (Solutions)：
⚝ 检查 Boost 库链接配置 (Check Boost Library Linkage Configuration)：检查项目的构建配置，确保 Boost 库的链接路径和库文件已正确配置。
⚝ 清理和重新编译 (Clean and Recompile)：尝试清理项目构建缓存，并重新编译整个项目，确保所有编译单元都完整编译。
⚝ 检查依赖库 (Check Dependencies)：检查 Boost.MultiIndex 的依赖库是否已正确安装和链接。
解决编译错误的关键在于仔细阅读错误信息，理解错误原因，并根据错误类型采取相应的解决方法。善用编译器的错误提示和调试工具，可以有效地定位和解决编译错误。
8.2.2 运行时错误 (Runtime Errors)
运行时错误通常比编译错误更难调试，因为它们只在程序运行时才会出现。
① 迭代器失效 (Iterator Invalidation)：
在使用 Multi-index 容器时，迭代器失效是一个常见的问题。
▮▮▮▮ⓐ 错误描述 (Error Description)：当容器的结构发生变化（例如插入、删除元素）时，某些迭代器可能会失效，导致程序崩溃或行为异常。
▮▮▮▮ⓑ 常见原因 (Common Causes)：
⚝ 在循环中使用失效的迭代器 (Using Invalidated Iterators in Loops)：在遍历容器时，如果在循环体内部进行了插入或删除操作，可能会导致正在使用的迭代器失效。
⚝ 使用 erase 后继续使用迭代器 (Continuing to Use Iterators After erase)：erase 操作会使指向被删除元素的迭代器以及之后元素的迭代器失效。
⚝ 在多线程环境下并发修改容器 (Concurrent Modification in Multi-threaded Environments)：在多线程环境下，如果多个线程同时修改同一个 Multi-index 容器，可能会导致迭代器失效。
▮▮▮▮ⓒ 解决方法 (Solutions)：
⚝ 遵循迭代器失效规则 (Follow Iterator Invalidation Rules)：仔细阅读 Boost.MultiIndex 文档，了解各种操作可能导致的迭代器失效情况，并在代码中避免使用失效的迭代器。
⚝ 使用返回值更新迭代器 (Update Iterators Using Return Values)：某些容器操作（例如 erase）会返回新的有效迭代器，可以使用这些返回值来更新迭代器，避免使用失效的迭代器。
⚝ 使用基于范围的 for 循环 (Use Range-based for Loops with Caution)：基于范围的 for 循环在某些情况下可能会隐藏迭代器失效问题。在使用基于范围的 for 循环时，要特别注意循环体内部是否会修改容器结构。
⚝ 在多线程环境下使用锁 (Use Locks in Multi-threaded Environments)：在多线程环境下，使用互斥锁等同步机制保护 Multi-index 容器，避免并发修改导致迭代器失效。
② 异常 (Exceptions)：
Boost.MultiIndex 在某些情况下可能会抛出异常，例如内存分配失败、键提取器抛出异常等。
▮▮▮▮ⓐ 错误描述 (Error Description)：程序在运行时抛出异常，导致程序终止或进入异常处理流程。
▮▮▮▮ⓑ 常见原因 (Common Causes)：
⚝ 内存不足 (Out of Memory)：在插入大量元素时，可能导致内存分配失败，抛出 std::bad_alloc 异常。
⚝ 键提取器抛出异常 (Key Extractor Throws Exception)：如果自定义的键提取器在提取键的过程中抛出异常，Boost.MultiIndex 会将该异常传播出去。
⚝ 逻辑错误导致异常 (Logic Errors Leading to Exceptions)：例如，在访问不存在的元素时，某些操作可能会抛出异常（虽然 Boost.MultiIndex 的查找操作通常不会抛出异常，而是返回迭代器）。
▮▮▮▮ⓒ 解决方法 (Solutions)：
⚝ 处理内存分配失败 (Handle Memory Allocation Failures)：使用 try-catch 块捕获 std::bad_alloc 异常，并进行适当的错误处理，例如释放已分配的资源、记录错误日志等。
⚝ 确保键提取器不抛出异常 (Ensure Key Extractors Do Not Throw Exceptions)：仔细检查自定义的键提取器代码，确保它们不会抛出异常。如果键提取逻辑可能抛出异常，需要进行异常处理，或者修改键提取逻辑，避免抛出异常。
⚝ 完善错误处理机制 (Improve Error Handling Mechanisms)：在程序中添加完善的异常处理机制，捕获并处理可能出现的异常，保证程序的健壮性。
③ 未定义行为 (Undefined Behavior)：
未定义行为是最危险的运行时错误，因为它们可能导致程序出现各种不可预测的错误，而且很难调试。
▮▮▮▮ⓐ 错误描述 (Error Description)：程序执行结果不确定，可能崩溃、产生错误的结果，或者看似正常运行，但实际上存在潜在的错误。
▮▮▮▮ⓑ 常见原因 (Common Causes)：
⚝ 违反先决条件 (Violating Preconditions)：Boost.MultiIndex 的某些操作有先决条件，例如在空容器上调用 begin() 或 end() 可能会导致未定义行为。
⚝ 数据竞争 (Data Races)：在多线程环境下，如果多个线程同时访问和修改同一个 Multi-index 容器，并且没有进行适当的同步，就可能发生数据竞争，导致未定义行为。
⚝ 使用已释放的内存 (Use After Free)：如果元素类型是指针或包含指针的类，并且没有正确管理内存，可能会出现使用已释放的内存的情况，导致未定义行为。
▮▮▮▮ⓒ 解决方法 (Solutions)：
⚝ 仔细阅读文档，理解先决条件 (Carefully Read Documentation and Understand Preconditions)：在使用 Boost.MultiIndex 的各种操作之前，仔细阅读文档，了解其先决条件，并在代码中确保满足这些条件。
⚝ 使用线程同步机制 (Use Thread Synchronization Mechanisms)：在多线程环境下，使用互斥锁、条件变量等线程同步机制，保护 Multi-index 容器，避免数据竞争。
⚝ 使用智能指针管理内存 (Use Smart Pointers to Manage Memory)：如果元素类型是指针或包含指针的类，使用智能指针（例如 std::shared_ptr、std::unique_ptr）来自动管理内存，避免内存泄漏和使用已释放的内存。
⚝ 使用内存检测工具 (Use Memory Detection Tools)：使用 Valgrind 等内存检测工具，帮助检测内存错误，例如内存泄漏、使用已释放的内存等。
避免运行时错误的关键在于编写健壮的代码，仔细处理各种边界情况和错误条件，并使用合适的工具进行调试和测试。
8.2.3 性能问题 (Performance Issues)
虽然 Boost.MultiIndex 设计为高效的容器，但在某些情况下，不当的使用方式可能导致性能问题 (Performance Issues)。
① 索引选择不当 (Inappropriate Index Selection)：
选择了不合适的索引类型，可能导致查询效率低下。
▮▮▮▮ⓐ 问题描述 (Problem Description)：例如，在需要频繁进行精确查找的场景下，如果选择了 ordered_index 而不是 hashed_index，查找效率会降低。
▮▮▮▮ⓑ 解决方法 (Solutions)：
⚝ 重新评估索引需求 (Re-evaluate Index Requirements)：重新审视应用场景，明确主要的查询和操作类型，选择最合适的索引类型。
⚝ 根据查询类型选择索引 (Choose Indices Based on Query Types)：对于精确查找，优先选择 hashed_index；对于范围查询和排序，选择 ordered_index；对于维护插入顺序，选择 sequenced_index；对于按位置访问，选择 random_access_index。
⚝ 组合使用多种索引 (Combine Multiple Index Types)：根据不同的查询需求，组合使用多种索引类型，以达到最佳性能。
② 键提取器效率低下 (Inefficient Key Extractors)：
键提取器的效率直接影响索引的性能。如果键提取器执行时间过长，会降低整体性能。
▮▮▮▮ⓐ 问题描述 (Problem Description)：例如，键提取器中进行了复杂的计算或字符串拷贝操作，导致键提取过程耗时过长。
▮▮▮▮ⓑ 解决方法 (Solutions)：
⚝ 优化键提取器代码 (Optimize Key Extractor Code)：检查键提取器代码，避免不必要的拷贝和复杂计算。尽可能使用引用返回键，避免在键提取器中进行耗时操作。
⚝ 使用 Lambda 表达式或内联函数 (Use Lambda Expressions or Inline Functions)：对于简单的键提取逻辑，使用 Lambda 表达式或内联函数，减少函数调用开销。
⚝ 预先计算键值 (Pre-calculate Key Values)：如果键的计算比较复杂，可以在插入元素之前预先计算好键值，并将键值作为元素的一部分存储，键提取器直接返回存储的键值，避免重复计算。
③ 过度索引 (Excessive Indexing)：
创建过多的索引会增加内存占用和维护成本，反而可能降低性能。
▮▮▮▮ⓐ 问题描述 (Problem Description)：为 Multi-index 容器创建了过多的索引，导致内存占用过高，插入和删除操作变慢。
▮▮▮▮ⓑ 解决方法 (Solutions)：
⚝ 精简索引数量 (Reduce the Number of Indices)：重新评估索引需求，只保留必要的索引。删除不常用或冗余的索引，减少内存占用和维护成本。
⚝ 按需创建索引 (Create Indices On Demand)：在某些情况下，可以考虑按需创建索引。例如，只有在需要按某个字段查询时才创建相应的索引。但这需要仔细权衡索引创建的开销和查询性能的提升。
④ 不当的容器操作 (Inappropriate Container Operations)：
某些容器操作在特定索引类型上可能效率较低。
▮▮▮▮ⓐ 问题描述 (Problem Description)：例如，在 sequenced_index 或 random_access_index 上进行按键查找操作，效率会非常低，因为这些索引类型不是为按键查找优化的。
▮▮▮▮ⓑ 解决方法 (Solutions)：
⚝ 使用合适的索引进行操作 (Use Appropriate Indices for Operations)：根据操作类型选择合适的索引。例如，按键查找使用 ordered_index 或 hashed_index，按位置访问使用 random_access_index，按插入顺序遍历使用 sequenced_index。
⚝ 避免在不合适的索引上进行低效操作 (Avoid Inefficient Operations on Inappropriate Indices)：避免在 sequenced_index 或 random_access_index 上进行按键查找等低效操作。如果需要按键查找，应该使用 ordered_index 或 hashed_index。
优化 Boost.MultiIndex 性能需要综合考虑索引类型选择、键提取器效率、索引数量以及容器操作方式等多个方面。通过仔细分析应用场景，选择合适的索引策略，并编写高效的代码，可以充分发挥 Boost.MultiIndex 的性能优势。
END_OF_CHAPTER
9. chapter 9： Boost.MultiIndex 的未来展望 (Future Trends of Boost Multi-index)
9.1 C++ 标准化与 Multi-index (C++ Standardization and Multi-index)
Boost 库在 C++ 生态系统中扮演着至关重要的角色，它不仅为开发者提供了大量高质量、经过充分测试的库，而且还常常作为 C++ 标准库的试验田和先锋。Boost.MultiIndex 作为 Boost 库中的重要组件，其发展与 C++ 标准化进程紧密相连。
① Boost 作为 C++ 标准的孵化器 (Boost as a C++ Standard Incubator)：
Boost 库的设计理念之一就是“先实现，后标准化”。许多现在被广泛应用于 C++ 标准库中的特性，例如智能指针 (std::shared_ptr, std::unique_ptr)、std::optional、std::variant 等，最初都是在 Boost 库中发展成熟，经过社区的广泛使用和验证，最终被吸纳进 C++ 标准。Boost.MultiIndex 也有潜力遵循类似的路径。
② Multi-index 的标准化可能性 (Standardization Potential of Multi-index)：
Multi-index 提供的多索引容器功能，在许多应用场景下都非常实用，能够显著提高代码的效率和可维护性。然而，C++ 标准库目前尚未提供类似的功能。随着 C++ 标准的不断演进，以及对更复杂数据结构和算法需求的增长，将 Multi-index 或其核心思想纳入 C++ 标准库的呼声可能会越来越高。
③ 标准化的挑战与机遇 (Challenges and Opportunities of Standardization)：
将 Boost.MultiIndex 标准化并非易事，可能面临以下挑战：
⚝ 复杂性 (Complexity)：Multi-index 本身是一个功能强大的库，但也相对复杂，其 API 和概念对于初学者来说可能有一定的学习曲线。如何简化和规范化 Multi-index 的接口，使其更易于被标准库接受，是一个需要考虑的问题。
⚝ 性能考量 (Performance Considerations)：标准库对性能有着极高的要求。在标准化过程中，需要对 Multi-index 的性能进行深入评估和优化，确保其在各种应用场景下都能保持高效。
⚝ 与其他标准库组件的整合 (Integration with Other Standard Library Components)：标准化的 Multi-index 需要能够良好地与其他 C++ 标准库组件（如算法、迭代器、容器等）协同工作，保持一致的设计风格和接口规范。
然而，标准化也为 Multi-index 带来了巨大的机遇：
⚝ 更广泛的应用 (Wider Adoption)：一旦成为 C++ 标准库的一部分，Multi-index 将会被更广泛地应用，成为 C++ 程序员工具箱中的一个常用工具，从而推动其技术的普及和发展。
⚝ 持续的改进和优化 (Continuous Improvement and Optimization)：标准化过程本身就是一个不断改进和优化的过程。为了满足标准的要求，Multi-index 将会得到更深入的审查和改进，从而提升其质量和性能。
⚝ 生态系统的繁荣 (Ecosystem Prosperity)：标准化的 Multi-index 将会促进围绕其构建的生态系统的繁荣，例如，可能会出现更多基于 Multi-index 的第三方库和工具，进一步扩展其应用领域。
④ 关注 C++ 标准委员会的动向 (Following the C++ Standard Committee's Trends)：
密切关注 C++ 标准委员会 (ISO/IEC JTC1/SC22/WG21) 的工作进展，特别是关于容器、算法和数据结构方面的提案，可以帮助我们了解 Multi-index 标准化的可能性和方向。参与 C++ 标准社区的讨论，贡献 Multi-index 的实践经验和需求，也有助于推动其标准化进程。
9.2 Multi-index 的发展趋势 (Development Trends of Multi-index)
即使 Boost.MultiIndex 没有立即被纳入 C++ 标准库，其自身也在不断发展和演进，以适应新的技术趋势和用户需求。以下是一些 Boost.MultiIndex 可能的发展趋势：
① 性能优化 (Performance Optimization)：
随着应用场景对性能要求的不断提高，Boost.MultiIndex 可能会继续在性能优化方面进行投入。这可能包括：
⚝ 更高效的索引结构 (More Efficient Index Structures)：探索和实现更高效的索引结构，例如，针对特定数据类型或访问模式优化的索引。
⚝ 编译时优化 (Compile-time Optimization)：利用 C++ 的编译时计算能力，例如模板元编程和 constexpr，在编译时进行更多的优化，减少运行时开销。
⚝ 并行和并发支持 (Parallel and Concurrent Support)：随着多核处理器和并行计算的普及，Boost.MultiIndex 可能会增强对并行和并发操作的支持，例如，提供线程安全的容器访问和并行算法。
② 功能扩展 (Feature Expansion)：
为了满足更广泛的应用需求，Boost.MultiIndex 可能会扩展其功能集：
⚝ 更多索引类型 (More Index Types)：引入新的索引类型，例如，支持地理空间索引、时间序列索引等，以适应特定领域的数据管理需求。
⚝ 更灵活的键提取器 (More Flexible Key Extractors)：提供更灵活和强大的键提取器，例如，支持基于多个成员变量的复合键、支持自定义的键转换和计算。
⚝ 与其他 Boost 库的集成 (Integration with Other Boost Libraries)：加强与 Boost 库中其他组件的集成，例如，与 Boost.Serialization 更好地协同工作，提供更便捷的序列化支持；与 Boost.Asio 结合，应用于异步编程场景。
③ 易用性提升 (Usability Improvement)：
为了降低学习曲线，吸引更多用户，Boost.MultiIndex 可能会在易用性方面进行改进：
⚝ 更清晰的 API 设计 (Clearer API Design)：简化和规范化 API 接口，使其更易于理解和使用。
⚝ 更完善的文档和示例 (Improved Documentation and Examples)：提供更详细、更易懂的文档，以及更丰富的示例代码，帮助用户快速上手和解决问题。
⚝ 更好的错误提示 (Better Error Messages)：改进编译时和运行时的错误提示信息，帮助用户更快地定位和解决问题。
④ 与其他编程语言的互操作性 (Interoperability with Other Programming Languages)：
随着跨语言编程需求的增加，Boost.MultiIndex 可能会考虑与其他编程语言的互操作性，例如：
⚝ C 接口封装 (C Interface Wrapping)：提供 C 接口的封装，方便其他语言（如 C、Python、Java 等）通过 FFI (Foreign Function Interface) 调用 Boost.MultiIndex 的功能。
⚝ 语言绑定 (Language Bindings)：开发针对特定语言的绑定库，例如，Python 绑定，使得在 Python 等脚本语言中也能方便地使用 Boost.MultiIndex。
⑤ 适应新的硬件架构 (Adaptation to New Hardware Architectures)：
随着硬件技术的不断发展，例如，新型存储设备、异构计算平台等，Boost.MultiIndex 可能会进行调整和优化，以更好地利用新的硬件架构，提升性能和效率。
总而言之，Boost.MultiIndex 作为一个成熟且强大的库，其未来发展既面临着标准化的机遇，也需要在性能、功能、易用性和互操作性等方面不断进步，以适应快速变化的软件开发环境和用户需求。持续关注 Boost 社区的动态，参与讨论和贡献，将有助于推动 Boost.MultiIndex 的持续发展，使其在未来的 C++ 开发中继续发挥重要作用。
END_OF_CHAPTER