@@ -361,6 +361,49 @@ b |= std::byte{0b0000'0001};     // 49
 int v = std::to_integer<int>(b); // explicit conversion to an integer: 49
 ```
 
+## 4.5 Associative container improvements
+
+C++17 added several more precise and more efficient operations to associative containers such as `std::map` / `std::unordered_map`:
+
+- `try_emplace`: inserts only when the key is absent; when the key already exists it does **not** modify the existing value nor move from its arguments, which makes it better than `emplace` for "insert if not present".
+- `insert_or_assign`: inserts a new element, or **overwrites** the value when the key already exists, returning whether an insertion happened.
+- Node-based operations `extract` / `merge`: `extract` detaches a node from the container without copying or moving the element, and `merge` splices nodes from another container directly in.
+
+```cpp
+#include <map>
+#include <string>
+
+std::map<int, std::string> m;
+m.try_emplace(1, "one");
+m.try_emplace(1, "uno");        // no effect, key 1 already present
+m.insert_or_assign(1, "ONE");   // overwrites with "ONE"
+
+std::map<int, std::string> other;
+other.insert(m.extract(1));     // move node 1 into other, no element copy
+
+std::map<int, std::string> more{{3, "three"}};
+m.merge(more);                  // splice more's nodes into m
+```
+
+## 4.6 Polymorphic allocators `std::pmr`
+
+C++17 introduced the `std::pmr` namespace in `<memory_resource>`, providing polymorphic allocators based on a **memory resource**. It decouples the *where to allocate* policy from the container type: the same `pmr` container backed by different memory resources is still a single type, avoiding the type bloat caused by template allocators.
+
+For instance, `std::pmr::monotonic_buffer_resource` can allocate from a pre-prepared buffer (even one on the stack) and frees everything only when the resource is destroyed — ideal for allocation-heavy workloads with a shared lifetime:
+
+```cpp
+#include <array>
+#include <cstddef>
+#include <memory_resource>
+#include <vector>
+
+std::array<std::byte, 1024> buffer;
+std::pmr::monotonic_buffer_resource pool{buffer.data(), buffer.size()};
+
+std::pmr::vector<int> v{&pool}; // allocates from the stack buffer, not the heap
+for (int i = 0; i < 5; ++i) v.push_back(i);
+```
+
 ## Conclusion
 
 This chapter briefly introduces the new containers in modern C++. Their usage is similar to that of the existing containers in C++. It is relatively simple, and you can choose the containers you need to use according to the actual scene, to get better performance.
 
@@ -361,6 +361,49 @@ b |= std::byte{0b0000'0001};    // 49
 int v = std::to_integer<int>(b); // 需要显式转换为整数：49
 ```
 
+## 4.5 关联容器的改进
+
+C++17 为 `std::map` / `std::unordered_map` 等关联容器增加了若干更精确、也更高效的操作：
+
+- `try_emplace`：仅当键不存在时才插入；当键已存在时，它**不会**修改已有的值，也不会从实参中移动，因此比 `emplace` 更适合「不存在则插入」的场景。
+- `insert_or_assign`：插入新元素，或在键已存在时**覆盖**其值，并返回是否发生了插入。
+- 基于节点的操作 `extract` / `merge`：`extract` 可以把一个节点从容器中「摘下」而不发生元素的拷贝或移动，`merge` 则能把另一个容器的节点直接「拼接」过来。
+
+```cpp
+#include <map>
+#include <string>
+
+std::map<int, std::string> m;
+m.try_emplace(1, "one");
+m.try_emplace(1, "uno");        // 无效果，键 1 已存在
+m.insert_or_assign(1, "ONE");   // 覆盖为 "ONE"
+
+std::map<int, std::string> other;
+other.insert(m.extract(1));     // 将节点 1 移动到 other，不拷贝元素
+
+std::map<int, std::string> more{{3, "three"}};
+m.merge(more);                  // 将 more 的节点拼接进 m
+```
+
+## 4.6 多态分配器 `std::pmr`
+
+C++17 在 `<memory_resource>` 中引入了 `std::pmr` 命名空间，提供了基于**内存资源 (memory resource)** 的多态分配器。它把「从哪里分配内存」这一策略与容器类型解耦：不同内存资源支撑的同一种 `pmr` 容器仍然是同一个类型，从而避免了模板分配器带来的类型膨胀。
+
+例如，`std::pmr::monotonic_buffer_resource` 可以从一块预先准备好的缓冲区（甚至是栈上的缓冲区）中分配内存，直到资源析构时才统一释放，非常适合分配密集且生命周期一致的场景：
+
+```cpp
+#include <array>
+#include <cstddef>
+#include <memory_resource>
+#include <vector>
+
+std::array<std::byte, 1024> buffer;
+std::pmr::monotonic_buffer_resource pool{buffer.data(), buffer.size()};
+
+std::pmr::vector<int> v{&pool}; // 从栈上的 buffer 分配，而非堆
+for (int i = 0; i < 5; ++i) v.push_back(i);
+```
+
 ## 总结
 
 本章简单介绍了现代 C++ 中新增的容器，它们的用法和传统 C++ 中已有的容器类似，相对简单，可以根据实际场景丰富的选择需要使用的容器，从而获得更好的性能。
 
@@ -0,0 +1,37 @@
+//
+// 4.6.associative.improvements.cpp
+// chapter 04 containers
+// modern c++ tutorial
+//
+// created by changkun at changkun.de
+// https://github.com/changkun/modern-cpp-tutorial
+//
+
+#include <iostream>
+#include <map>
+#include <string>
+
+int main() {
+    std::map<int, std::string> m;
+
+    // try_emplace: only inserts if the key is absent; does not touch
+    // the mapped value (or move from arguments) when the key exists.
+    m.try_emplace(1, "one");
+    m.try_emplace(1, "uno"); // no effect, key 1 already present
+
+    // insert_or_assign: inserts, or overwrites the existing value.
+    m.insert_or_assign(1, "ONE");
+    m.insert_or_assign(2, "TWO");
+
+    // extract: detach a node without copying/moving the element, then
+    // merge nodes from another map.
+    std::map<int, std::string> other;
+    other.insert(m.extract(2)); // move node 2 into `other`
+
+    std::map<int, std::string> more{{3, "three"}};
+    m.merge(more); // splice nodes from `more` into `m`
+
+    for (const auto& [k, v] : m)
+        std::cout << k << " => " << v << "\n";
+    std::cout << "other has key 2: " << other.count(2) << "\n";
+}
@@ -0,0 +1,28 @@
+//
+// 4.7.pmr.cpp
+// chapter 04 containers
+// modern c++ tutorial
+//
+// created by changkun at changkun.de
+// https://github.com/changkun/modern-cpp-tutorial
+//
+
+#include <array>
+#include <cstddef>
+#include <iostream>
+#include <memory_resource>
+#include <vector>
+
+int main() {
+    // A monotonic_buffer_resource hands out memory from a fixed buffer
+    // (here on the stack) and frees nothing until destroyed. The pmr
+    // container allocates through the resource instead of the heap.
+    std::array<std::byte, 1024> buffer;
+    std::pmr::monotonic_buffer_resource pool{buffer.data(), buffer.size()};
+
+    std::pmr::vector<int> v{&pool};
+    for (int i = 0; i < 5; ++i) v.push_back(i);
+
+    for (int x : v) std::cout << x << ' ';
+    std::cout << std::endl;
+}