C++类中自定义排序比较器报错：非静态引用与静态函数访问成员问题

你遇到的这两个错误其实是C++中成员函数访问权限和std::sort对比较器要求的典型问题，我来一步步帮你理清并解决：

问题根源拆解 #

1. 第一个错误："reference to non-static member function must be called"
   std::sort的第三个参数需要一个可调用对象（比如函数指针、lambda、重载了operator()的类）。非静态成员函数隐含了一个this指针作为参数，所以它的函数签名和sort要求的bool(char, char)不匹配，直接传递非静态成员函数的话，编译器不知道要绑定哪个类实例的this，因此报错。

2. 第二个错误："invalid use of member 'mat' in static member function"
   静态成员函数属于类本身，不属于任何具体的实例，所以它没有this指针，自然无法访问类的非静态成员变量mat——因为mat是每个类实例独有的，静态函数不知道要访问哪个实例的mat。

可行的解决方案 #

方案1：使用Lambda表达式捕获this（最简洁推荐） #

在调用std::sort的地方，用lambda表达式作为比较器，通过捕获this来访问类的非静态成员mat，同时把递归的comp_改成非静态成员函数：

#include <algorithm>
#include <string>

class Solution { 
public: 
    int mat[26][26]; 

    // 改成非静态成员函数，这样可以访问this->mat
    bool comp_(char a, char b, int i) { 
        if (i == 26) { return a < b; } 
        if (mat[a-'A'][i] > mat[b-'A'][i]) { return true; } 
        else if (mat[a-'A'][i] < mat[b-'A'][i]) { return false; } 
        return comp_(a, b, i+1); 
    } 

    void sortString(std::string& str) { // 假设这是你调用sort的成员函数
        std::sort(str.begin(), str.end(), [this](char a, char b) {
            return this->comp_(a, b, 0);
        });
    }
};

方案2：使用仿函数（Functor） #

如果你的代码需要兼容C++11之前的版本，或者更倾向于用类的方式封装比较逻辑，可以定义一个嵌套的仿函数类，在构造时传入当前实例的mat指针：

#include <algorithm>
#include <string>

class Solution { 
public: 
    int mat[26][26]; 

    // 嵌套仿函数类
    class Comparator {
    private:
        int (*mat_ptr)[26]; // 保存外部类mat的指针
    public:
        Comparator(int (*mat)[26]) : mat_ptr(mat) {}

        bool operator()(char a, char b) const {
            return comp_(a, b, 0, mat_ptr);
        }

        static bool comp_(char a, char b, int i, int (*mat)[26]) {
            if (i == 26) { return a < b; } 
            if ((*mat)[a-'A'][i] > (*mat)[b-'A'][i]) { return true; } 
            else if ((*mat)[a-'A'][i] < (*mat)[b-'A'][i]) { return false; } 
            return comp_(a, b, i+1, mat); 
        }
    };

    void sortString(std::string& str) {
        std::sort(str.begin(), str.end(), Comparator(mat));
    }
};

方案3：将mat改为静态成员（仅当所有实例共享同一个mat时适用） #

如果你的mat是所有Solution实例共用的全局数据，可以把它改成静态成员，这样静态的comp_和comp就能直接访问了：

#include <algorithm>
#include <string>

class Solution { 
public: 
    static int mat[26][26]; // 静态成员声明

    static bool comp_(char a, char b, int i) { 
        if (i == 26) { return a < b; } 
        if (mat[a-'A'][i] > mat[b-'A'][i]) { return true; } 
        else if (mat[a-'A'][i] < mat[b-'A'][i]) { return false; } 
        return comp_(a, b, i+1); 
    } 

    static bool comp(char a, char b) { 
        return comp_(a, b, 0); 
    }

    void sortString(std::string& str) {
        std::sort(str.begin(), str.end(), comp);
    }
};

// 静态成员必须在类外定义
int Solution::mat[26][26] = {0}; // 初始化可以根据需求修改

总结 #

• 如果你每个Solution实例的mat都不一样，**方案1（Lambda）**是最简洁高效的选择；
• 如果需要兼容旧标准，或者更注重封装性，选方案2（仿函数）；
• 只有当mat是全局共享数据时，才考虑方案3（静态成员）。

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