如何让priority_queue的比较函数访问类的外部成员变量

方案一：嵌套比较器类持有外部map指针 #

保留你原本的嵌套类结构，修正关键错误并完善实现：

class MyClass
{
    class IntCompare
    {
    public:
        // 显式构造函数，传入map指针
        explicit IntCompare(std::map<int, bool>* map_ptr) : m_map_ptr(map_ptr) {}
        
        // 允许拷贝构造（编译器默认生成即可，确保指针正确传递）
        IntCompare(const IntCompare&) = default;
        IntCompare& operator=(const IntCompare&) = default;

        // 必须是public且const的operator()，供priority_queue调用
        bool operator()(int lhs, int rhs) const
        {
            // 确保指针有效，避免空指针访问
            if (!m_map_ptr) {
                // fallback到默认排序逻辑，比如降序
                return lhs > rhs;
            }

            // 这里实现你的自定义比较逻辑，直接使用m_map_ptr访问外部map
            auto lhs_entry = m_map_ptr->find(lhs);
            auto rhs_entry = m_map_ptr->find(rhs);

            bool lhs_active = (lhs_entry != m_map_ptr->end()) && lhs_entry->second;
            bool rhs_active = (rhs_entry != m_map_ptr->end()) && rhs_entry->second;

            // 示例逻辑：活跃（map中值为true）的元素优先级更高
            if (lhs_active != rhs_active) {
                return !lhs_active; // 返回false表示lhs优先级更高，不需要交换位置
            }
            // 活跃状态相同时，按默认降序排列
            return lhs > rhs;
        }
    private:
        std::map<int, bool>* m_map_ptr = nullptr;
    };

    std::map<int, bool> m_MyMap;
    std::priority_queue<int, std::vector<int>, IntCompare> m_MyPriorityQueue;

public:
    // 初始化队列时传入持有map指针的比较器实例
    MyClass() : m_MyPriorityQueue(IntCompare(&m_MyMap)) {}
};

关键修正点： #

• 把IntCompare的构造函数和operator()改为public，否则priority_queue无法访问这些成员
• 让operator()成为const成员函数，因为priority_queue在调用比较器时会使用const引用
• 确保比较器支持拷贝构造，priority_queue内部会拷贝比较器实例

方案二：使用lambda+std::function（更简洁） #

不需要定义嵌套类，直接用lambda捕获this，通过std::function作为比较器类型：

#include <functional> // 需要包含这个头文件

class MyClass
{
    std::map<int, bool> m_MyMap;
    // 用std::function作为比较器类型，接受bool(int,int)的函数对象
    std::priority_queue<int, std::vector<int>, std::function<bool(int, int)>> m_MyPriorityQueue;

public:
    MyClass() 
        : m_MyPriorityQueue([this](int lhs, int rhs) {
            // 直接访问当前MyClass对象的m_MyMap成员
            auto lhs_entry = m_MyMap.find(lhs);
            auto rhs_entry = m_MyMap.find(rhs);

            bool lhs_active = (lhs_entry != m_MyMap.end()) && lhs_entry->second;
            bool rhs_active = (rhs_entry != m_MyMap.end()) && rhs_entry->second;

            if (lhs_active != rhs_active) {
                return !lhs_active;
            }
            return lhs > rhs;
        })
    {}
};

优势： #

• 代码更简洁，省去嵌套类的定义
• lambda直接捕获this，可以直接访问m_MyMap，无需手动管理指针
• 缺点是std::function会带来微小的性能开销，绝大多数场景下可以忽略

注意事项 #

• 确保m_MyMap的生命周期长于m_MyPriorityQueue：因为两者都是MyClass的成员，声明顺序上m_MyMap在m_MyPriorityQueue之前，所以构造时指针有效，只要MyClass对象存在，指针就不会失效
• 不要在比较器中修改m_MyMap（除非你能保证线程安全），因为priority_queue的内部结构依赖比较器的返回值稳定，频繁修改map可能导致队列的排序逻辑混乱

内容的提问来源于stack exchange，提问作者dwnenr