为含多数值字段的POD struct重载多版本比较运算符的方法

直接为结构体重载多个同名operator<是不可行的，因为编译器无法区分参数列表完全相同的重载。但可以通过以下几种方式实现类似“按不同字段使用<”的便捷效果：

方法1：用命名空间隔离不同的运算符重载 #

为每个字段的比较逻辑单独定义命名空间，在需要按该字段比较的函数中引入对应命名空间，利用**参数依赖查找(ADL)**让编译器选择正确的重载：

#include <vector>
#include <algorithm>
#include <ctime>

// 抽象文件的POD结构体
struct FileInfo {
    size_t size;                // 文件大小
    time_t last_modified;       // 最后修改时间
    unsigned int item_count;    // 包含的文件/子目录数量
};

// 按文件大小比较的命名空间
namespace sort_by_size {
    bool operator<(const FileInfo& lhs, const FileInfo& rhs) {
        return lhs.size < rhs.size;
    }
}

// 按修改时间比较的命名空间
namespace sort_by_mod_time {
    bool operator<(const FileInfo& lhs, const FileInfo& rhs) {
        return lhs.last_modified < rhs.last_modified;
    }
}

// 按文件大小排序的函数
void sortBySize(std::vector<FileInfo>& files) {
    using namespace sort_by_size;
    // 用std::sort替代手动冒泡，效率更高
    std::sort(files.begin(), files.end(), [](const auto& a, const auto& b) {
        return a < b; // 此处自动调用sort_by_size中的operator<
    });
}

// 按修改时间排序的函数
void sortByModTime(std::vector<FileInfo>& files) {
    using namespace sort_by_mod_time;
    std::sort(files.begin(), files.end(), [](const auto& a, const auto& b) {
        return a < b; // 此处自动调用sort_by_mod_time中的operator<
    });
}

方法2：带标签的包装器类 #

定义空的标签结构体，再创建一个包装器类持有原结构体的引用，为不同标签的包装器重载operator<：

#include <vector>
#include <algorithm>
#include <ctime>

struct FileInfo {
    size_t size;
    time_t last_modified;
    unsigned int item_count;
};

// 标签结构体，用于区分不同的比较维度
struct BySize {};
struct ByModTime {};
struct ByItemCount {};

// 带标签的包装器，持有FileInfo的const引用
template <typename Tag>
struct TaggedFile {
    const FileInfo& file;
    explicit TaggedFile(const FileInfo& f) : file(f) {}
};

// 为不同标签的包装器重载<运算符
bool operator<(const TaggedFile<BySize>& lhs, const TaggedFile<BySize>& rhs) {
    return lhs.file.size < rhs.file.size;
}

bool operator<(const TaggedFile<ByModTime>& lhs, const TaggedFile<ByModTime>& rhs) {
    return lhs.file.last_modified < rhs.file.last_modified;
}

bool operator<(const TaggedFile<ByItemCount>& lhs, const TaggedFile<ByItemCount>& rhs) {
    return lhs.file.item_count < rhs.file.item_count;
}

// 使用示例
void sortByItemCount(std::vector<FileInfo>& files) {
    std::sort(files.begin(), files.end(), [](const auto& a, const auto& b) {
        return TaggedFile<ByItemCount>(a) < TaggedFile<ByItemCount>(b);
    });
}

方法3：模板化的仿函数（推荐） #

如果不需要严格使用<运算符，直接用模板化的仿函数配合std::sort会更简洁灵活，这也是C++排序场景的常规做法：

#include <vector>
#include <algorithm>
#include <ctime>

struct FileInfo {
    size_t size;
    time_t last_modified;
    unsigned int item_count;
};

// 模板化仿函数，支持任意字段的比较
template <auto Field>
struct FieldComparator {
    bool operator()(const FileInfo& lhs, const FileInfo& rhs) const {
        return lhs.*Field < rhs.*Field;
    }
};

// 使用示例
void sortBySize(std::vector<FileInfo>& files) {
    std::sort(files.begin(), files.end(), FieldComparator<&FileInfo::size>());
}

void sortByModTime(std::vector<FileInfo>& files) {
    std::sort(files.begin(), files.end(), FieldComparator<&FileInfo::last_modified>());
}

注意事项 #

1. 避免手动实现冒泡排序，std::sort是经过优化的排序算法，效率远高于手动嵌套循环。
2. 如果需要支持升序/降序切换，可以在仿函数或运算符重载中调整比较逻辑，或者配合std::greater。

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