C++20中如何正确声明带自定义比较器的类私有优先队列？

一、结构体比较器的合规性与C++20优化方向 #

结构体形式的比较器完全符合现代C规范，从C98沿用至今，在C20中依然合法且实用。不过C20提供了一些优化点，能让它更高效简洁：

• 添加constexpr/consteval：如果比较逻辑是编译期可计算的，把operator()声明为constexpr（或consteval，若完全不需要运行期计算），编译器可在编译期完成部分逻辑优化，提升运行效率。示例：

struct CompareTuple {
    constexpr bool operator()(const std::tuple<int, std::string>& a, const std::tuple<int, std::string>& b) const noexcept {
        return std::get<0>(a) > std::get<0>(b); // 示例小顶堆逻辑
    }
};

• 标注noexcept：若比较操作不会抛出异常，加上noexcept能让编译器生成更高效的代码，同时符合现代C++对异常安全的标注要求。
• 坚持const&传参：避免不必要的tuple拷贝，这也是现代C++的基本规范。

需要明确：结构体比较器并非过时方案——在需要复用比较逻辑、或逻辑复杂的场景下，它依然是最优选择之一，毕竟lambda存在生命周期或复用性的限制。

二、头文件中用lambda作为类内私有优先队列的比较器 #

lambda是匿名类型，无法直接作为std::priority_queue的模板参数，但C++11及以后有几种可行方案：

方法1：用std::function包装（直观但有轻微开销） #

这种写法最容易理解，但会引入多态调用的运行时开销，适合对性能要求不极致的场景：

#include <queue>
#include <tuple>
#include <functional>

class Foo {
private:
    using Tuple = std::tuple<int, std::string>;
    std::priority_queue<Tuple, std::vector<Tuple>,
                        std::function<bool(const Tuple&, const Tuple&)>> pq;
public:
    Foo() {
        auto cmp = [](const Tuple& a, const Tuple& b) {
            return std::get<0>(a) > std::get<0>(b);
        };
        pq = decltype(pq)(cmp);
    }
};

方法2：C++20用std::type_identity推导（零开销最优解） #

C++20的std::type_identity可以延迟推导lambda类型，结合类内初始化实现零开销的lambda比较器，是当前最简洁高效的lambda方案：

#include <queue>
#include <tuple>
#include <type_traits>

class Foo {
private:
    using Tuple = std::tuple<int, std::string>;
    // 先定义lambda比较器
    auto cmp = [](const Tuple& a, const Tuple& b) noexcept {
        return std::get<0>(a) > std::get<0>(b);
    };
    // 用type_identity获取lambda类型作为比较器
    std::priority_queue<Tuple, std::vector<Tuple>,
                        std::type_identity_t<decltype(cmp)>> pq{cmp};
};

方法3：C++17及以后用模板类封装（零开销） #

如果未升级到C++20，可以用模板类封装lambda，实现零开销：

#include <queue>
#include <tuple>

// 模板类包装lambda，继承lambda以复用其operator()
template<typename Cmp>
struct LambdaWrapper : Cmp {
    using Cmp::operator();
};

// 辅助推导模板参数
template<typename Cmp>
LambdaWrapper(Cmp) -> LambdaWrapper<Cmp>;

class Foo {
private:
    using Tuple = std::tuple<int, std::string>;
    // 声明优先队列，指定LambdaWrapper包装后的lambda类型
    std::priority_queue<Tuple, std::vector<Tuple>,
                        LambdaWrapper<decltype([](const Tuple& a, const Tuple& b) noexcept {
                            return std::get<0>(a) > std::get<0>(b);
                        })>> pq;
public:
    Foo() : pq(LambdaWrapper{[](const Tuple& a, const Tuple& b) noexcept {
        return std::get<0>(a) > std::get<0>(b);
    }}) {}
};

三、方案选择建议 #

• 若比较逻辑需要复用，带C++20优化的结构体比较器是最清晰、易维护的最优选择；
• 若比较逻辑仅服务于当前优先队列，且使用C++20，type_identity+lambda是零开销且简洁的最佳方案；
• 若处于C++11/17环境，可根据性能需求选择std::function（简单）或模板封装（零开销）。

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