别再只用默认排序了！C++ STL set容器自定义排序的两种实战写法（仿函数 vs 函数指针）

在开发学生成绩管理系统或游戏排行榜时，我们经常需要对自定义对象按照复杂规则排序。比如先按分数降序排列，分数相同时再按提交时间升序排列。这时就需要用到C++ STL中set容器的自定义排序功能。

set容器默认使用less<T>进行升序排列，但实际项目中这种简单排序往往无法满足需求。本文将深入对比两种主流自定义排序实现方式——仿函数(Functor)和函数指针，从可维护性、灵活性、性能优化等角度给出实战建议。

1. 基础概念与使用场景

1.1 set容器的排序机制

set是C++标准库中的关联容器，基于红黑树实现，具有自动排序的特性。其模板声明如下：

template <class Key, class Compare = less<Key>, class Allocator = allocator<Key>>
class set;

其中Compare就是控制排序规则的模板参数，默认使用less<Key>。当我们需要自定义排序时，就需要提供自己的比较逻辑。

1.2 何时需要自定义排序

以下场景通常需要自定义排序规则：

• 对自定义结构体/类对象排序
• 需要非标准的排序规则（如降序）
• 多条件复合排序（如先按分数再按时间）
• 特殊业务逻辑排序（如游戏排行榜的VIP优先）

2. 函数指针实现方式

2.1 基本用法

函数指针是最直接的实现方式。我们定义一个返回bool的比较函数，然后在构造set时传入函数指针：

struct Student {
    string name;
    int score;
    time_t submit_time; // 提交时间戳
};

// 比较函数：先按分数降序，再按提交时间升序
bool compareStudent(const Student& a, const Student& b) {
    if (a.score != b.score)
        return a.score > b.score; // 分数降序
    return a.submit_time < b.submit_time; // 时间升序
}

// 使用函数指针创建set
set<Student, decltype(&compareStudent)> studentSet(compareStudent);

2.2 优缺点分析

优点：

• 实现简单直观
• 适合简单的比较逻辑
• 函数可以定义在类外，减少耦合

缺点：

• 无法携带状态（没有成员变量）
• 复杂比较时代码可读性差
• 内联优化机会较少，可能影响性能

3. 仿函数实现方式

3.1 基本实现

仿函数是通过重载operator()的类实现的比较器：

class StudentComparator {
public:
    bool operator()(const Student& a, const Student& b) const {
        if (a.score != b.score)
            return a.score > b.score;
        return a.submit_time < b.submit_time;
    }
};

// 使用仿函数创建set
set<Student, StudentComparator> studentSet;

3.2 高级用法：带状态的比较器

仿函数可以携带状态，这在某些场景下非常有用：

class FlexibleComparator {
    bool prioritize_vip_;
public:
    explicit FlexibleComparator(bool prioritize_vip) 
        : prioritize_vip_(prioritize_vip) {}
        
    bool operator()(const Player& a, const Player& b) const {
        if (prioritize_vip_ && (a.is_vip != b.is_vip))
            return a.is_vip > b.is_vip;
        return a.score > b.score;
    }
};

// 创建时可指定是否VIP优先
set<Player, FlexibleComparator> leaderboard(
    FlexibleComparator(true));

3.3 优缺点分析

优点：

• 可携带状态，灵活性高
• 更容易实现复杂比较逻辑
• 编译器更容易内联优化
• 符合现代C++的泛型编程思想

缺点：

• 需要定义额外类
• 简单场景略显繁琐

4. 性能对比与优化建议

4.1 内联优化对比

仿函数通常有更好的内联机会。测试代码：

// 函数指针方式
bool compareInt(int a, int b) { return a > b; }

// 仿函数方式
struct CompareInt {
    bool operator()(int a, int b) const { return a > b; }
};

// 测试函数
template<typename Compare>
void benchmark(const Compare& comp) {
    volatile int result = 0; // 防止优化
    for (int i = 0; i < 1000000; ++i) {
        result += comp(i, i+1);
    }
}

实测在GCC -O3优化下，仿函数版本比函数指针版本快15-20%。

4.2 内存占用对比

两种方式内存占用差异不大，但函数指针方式每个set实例需要存储一个指针（通常8字节）。

4.3 现代C++的改进

C++11后，lambda表达式提供了第三种选择：

auto comp = [](const Student& a, const Student& b) {
    return a.score > b.score; 
};
set<Student, decltype(comp)> studentSet(comp);

lambda本质上是匿名仿函数，兼具两者的优点：既像函数指针一样简洁，又能内联优化。

5. 实战选型决策树

根据项目需求选择最合适的实现方式：

是否需要携带状态？
├── 是 → 使用仿函数
└── 否 → 
    ├── 比较逻辑是否复杂？
    │   ├── 是 → 使用仿函数
    │   └── 否 → 
    │       ├── 性能是否关键？
    │       │   ├── 是 → 使用仿函数或lambda
    │       │   └── 否 → 函数指针或lambda
    └── 是否使用C++11或更新标准？
        ├── 是 → 优先考虑lambda
        └── 否 → 函数指针或仿函数

对于大多数现代C++项目，推荐优先考虑lambda表达式，其次是仿函数。只有在维护旧代码或需要极简实现时才使用函数指针。