C++ std::shared_ptr的owner_before在弱排序中的使用

C++ 标准库中的智能指针 std::shared_ptr 提供了自动内存管理功能，但在将其作为关联容器（如 std::set 或 std::map 的键）的元素时，直接使用默认的排序规则往往会引发意料之外的逻辑错误，特别是在涉及指针别名或 std::weak_ptr 的场景下。owner_before 成员函数提供了一种基于“所有权”而非“指针值”的弱排序机制，确保了排序逻辑与对象生命周期的严格一致性。

1. 理解核心概念：控制块与指针值

要掌握 owner_before，必须先区分两个概念：指针值和所有权。

• 指针值：智能指针内部存储的裸指针地址，即 get() 返回的值。
• 所有权：管理该对象生命周期的控制块。多个 shared_ptr 可以指向同一个对象的不同成员（别名构造），但它们共享同一个控制块。

std::shared_ptr 的默认比较运算符（在 C++20 之前）比较的是指针值。如果两个指针指向同一个对象的不同成员，默认排序会认为它们不相等。但如果我们希望在容器中将它们视为“属于同一组”，就必须使用 owner_before。

2. 解决“别名指针”排序不一致问题

当使用别名构造函数创建 shared_ptr 时，我们会得到一个拥有对象 A，但指向对象 A 成员的指针。如果将其存入依赖指针值排序的容器，会导致同一个所有权被当作不同的键处理。

按以下步骤操作以理解并解决此问题：

1. 定义一个包含成员变量的结构体 Node。
2. 创建一个主控 std::shared_ptr<Node>。
3. 利用别名构造函数创建指向 Node 成员的 shared_ptr<int>。
4. 观察直接比较与 owner_before 的区别。

下表展示了两种排序方式的本质区别：

3. 使用 std::weak_ptr 作为容器键（实战应用）

std::weak_ptr 不支持直接的比较运算符（因为它可能随时过期，且没有明确的裸指针语义），因此无法直接放入 std::set。必须使用 owner_before 或其封装器 std::owner_less 来实现弱排序。

按以下步骤实现一个基于 std::weak_ptr 的集合：

1. 包含必要的头文件 <memory> 和 <set>。

2. 声明容器类型，显式指定比较器为 std::owner_less。

   std::set 的模板参数定义为 std::set<std::weak_ptr<MyClass>, std::owner_less<std::weak_ptr<MyClass>>>。std::owner_less 内部会自动调用 owner_before，从而基于控制块进行排序。

3. 编写代码创建对象并管理其生命周期。

以下代码展示了完整的实现逻辑：

#include <iostream>
#include <memory>
#include <set>

struct Widget {
    int id;
    Widget(int i) : id(i) { std::cout << "Widget " << id << " created.\n"; }
    ~Widget() { std::cout << "Widget " << id << " destroyed.\n"; }
};

int main() {
    // 定义使用 owner_less 的 weak_ptr 集合
    // 注意：std::owner_less 默认会处理 shared_ptr 和 weak_ptr 之间的混合比较
    std::set<std::weak_ptr<Widget>, std::owner_less<std::weak_ptr<Widget>>> widget_set;

    {
        // 创建一个新的 Widget 对象
        auto sp1 = std::make_shared<Widget>(1);
        auto sp2 = std::make_shared<Widget>(2);

        // 将 weak_ptr 插入集合
        widget_set.insert(sp1);
        widget_set.insert(sp2);

        // 尝试插入指向 sp1 控制块的另一个 weak_ptr
        std::weak_ptr<Widget> wp_alias(sp1);
        auto insert_result = widget_set.insert(wp_alias);

        // 检查插入结果
        if (!insert_result.second) {
            std::cout << "Insertion failed: Duplicate ownership detected.\n";
        }

        // 遍历集合（需要检查 weak_ptr 是否过期）
        std::cout << "Current set size: " << widget_set.size() << "\n";
        for (const auto& wp : widget_set) {
            if (auto sp = wp.lock()) {
                std::cout << "Alive Widget ID: " << sp->id << "\n";
            }
        }

    } // 离开作用域，sp1 和 sp2 析构，Widget 对象被销毁

    std::cout << "After scope:\n";
    // 此时 weak_ptr 应该全部过期
    std::cout << "Current set size: " << widget_set.size() << " (contains expired weak_ptrs)\n";

    return 0;
}

分析代码执行结果：

• 插入逻辑：sp1 和 wp_alias 指向相同的控制块。尽管它们可能是不同的变量，std::owner_less 判定它们相等，因此第二次插入失败。
• 生命周期管理：集合存储的是弱引用，不影响对象的销毁。

4. 自定义比较函数中使用 owner_before

如果你不想使用 std::owner_less，或者需要在更复杂的谓词中使用，可以直接调用成员函数 .owner_before()。

按以下步骤自定义比较逻辑：

1. 定义一个 Lambda 表达式或函数对象。
2. 捕获或传递两个智能指针。
3. 调用左侧指针的 .owner_before(右侧指针) 方法。
4. 返回布尔结果。

代码示例：

auto custom_comparator = [](const std::shared_ptr<int>& a, const std::shared_ptr<int>& b) {
    // 使用 owner_before 确保基于所有权排序
    return a.owner_before(b);
};

std::set<std::shared_ptr<int>, decltype(custom_comparator)> my_set(custom_comparator);

auto ptr1 = std::make_shared<int>(10);
auto ptr2 = ptr1; // 拷贝，共享所有权

// 假设有一个别名构造（指向同一个控制块的不同地址）
struct Base { int x; };
auto base_ptr = std::make_shared<Base>();
auto alias_ptr = std::shared_ptr<int>(base_ptr, &base_ptr->x);

my_set.insert(ptr1);
my_set.insert(alias_ptr); // 即使指向不同内存地址，因控制块相同可能被视为重复（取决于具体实现和类型转换）

在此示例中，owner_before 确保了即使 alias_ptr 的裸指针地址与 ptr1 不同（类型甚至不同，若忽略类型转换限制），只要它们源于同一个控制块，排序逻辑就能保持一致性。

5. 注意事项与常见陷阱

在使用 owner_before 时，必须严格遵守以下规则以避免逻辑漏洞：

1. 不要将其用于逻辑相等性判断。a.owner_before(b) == false 且 b.owner_before(a) == false 并不绝对意味着 a == b（虽然对于共享所有权的 shared_ptr 通常如此，但在复杂泛型代码中需谨慎）。确定相等应使用 owner_equal（C++26）或 !a.owner_before(b) && !b.owner_before(a)。
2. 确保类型兼容。owner_before 支持在 shared_ptr、weak_ptr 甚至 shared_ptr 与 weak_ptr 之间混合比较。不要试图比较完全不相关的智能指针类型。
3. 清理过期指针。对于 std::set<std::weak_ptr>，owner_before 会保留已销毁对象的 weak_ptr 占位符。定期调用 expired() 并清理是必要的维护步骤。

按以下步骤清理集合中的过期指针：

1. 获取迭代器指向集合开始。
2. 循环检查每个元素的 .expired() 状态。
3. 调用 erase 移除过期的迭代器。

for (auto it = widget_set.begin(); it != widget_set.end(); ) {
    if (it->expired()) {
        it = widget_set.erase(it); // 删除并移动到下一个有效元素
    } else {
        ++it;
    }
}