LeetCode提交报错：静态函数与非静态成员变量冲突及效率咨询

你遇到的这几个报错其实都是C++里静态成员和非静态成员访问规则的典型坑，咱们一个个拆解原因，再给你靠谱的解决方案：

为什么会出现这些报错？ #

• 静态函数用非静态成员变量报错：静态成员函数属于类本身，不属于某个具体的对象，所以它没法直接访问非静态的mep——因为非静态成员是每个对象独有的，静态函数根本不知道要访问哪个对象的mep。
• 静态mep提示未定义：C++里类的静态成员变量仅仅在类里声明是不够的，必须在类的外部进行定义（也就是分配内存），否则链接器找不到它，就会报"undefined reference"。
• 非静态成员函数作为sort比较器报错：std::sort要求比较器是一个可以独立调用的可调用对象（比如普通函数、lambda、函数对象），而非静态成员函数必须依附于某个对象才能调用，直接传comp的话，sort不知道该用哪个Solution对象来调用这个函数，所以报错。

靠谱的解决方案 #

方案1：用Lambda表达式（最推荐，简洁且安全） #

直接在isAlienSorted函数里用lambda捕获当前的mep，既不用折腾静态成员，也能正确访问到映射关系，还能顺便修正原代码里的逻辑bug：

class Solution {
public:
    bool isAlienSorted(vector<string>& words, string order) {
        unordered_map<char,int> mep;
        for(int i=0;i<order.size();i++){
            mep[order[i]]=i;
        }
        vector<string> temp = words;
        // 捕获mep的引用，作为sort的比较器
        sort(temp.begin(), temp.end(), [&mep](const string& a, const string& b){
            int n = min(a.size(), b.size());
            for(int i=0;i<n;i++){
                int diff = mep[a[i]] - mep[b[i]];
                if(diff != 0){
                    return diff > 0; // 字符优先级高的排在前面
                }
            }
            // 原代码直接return true是错误的！前面字符都相同时，短字符串应该排在前面
            return a.size() <= b.size();
        });
        return temp == words;
    }
};

注意：你的原comp函数最后直接return true会导致错误，比如当a是"apple"、b是"app"时，按规则b应该排在a前面，但原逻辑会返回true，让a排在前面，这里已经修正了这个问题。

方案2：使用静态成员+类外初始化（不推荐，有状态残留风险） #

如果一定要用静态函数的写法，需要把mep也改成静态，并且在类外初始化，还要记得每次调用前清空静态变量：

class Solution {
public:
    static unordered_map<char,int> mep;
    static bool comp(const string& a, const string& b){
        int n = min(a.size(), b.size());
        for(int i=0;i<n;i++){
            int diff = mep[a[i]] - mep[b[i]];
            if(diff != 0){
                return diff > 0;
            }
        }
        return a.size() <= b.size();
    }
    bool isAlienSorted(vector<string>& words, string order) {
        mep.clear(); // 必须清空，否则多次调用会残留之前的状态
        for(int i=0;i<order.size();i++){
            mep[order[i]]=i;
        }
        vector<string> temp = words;
        sort(temp.begin(), temp.end(), comp);
        return temp == words;
    }
};
// 类外初始化静态成员变量，否则链接器会报错
unordered_map<char,int> Solution::mep;

这种方式的问题在于，静态mep是整个Solution类共享的，如果LeetCode批量运行测试用例，很容易因为状态残留导致错误结果，所以不推荐。

方案3：使用函数对象（Functor） #

把比较器做成一个内部类，重载()运算符，持有mep的引用，本质上和lambda是一样的，只是写法更繁琐：

class Solution {
public:
    bool isAlienSorted(vector<string>& words, string order) {
        unordered_map<char,int> mep;
        for(int i=0;i<order.size();i++){
            mep[order[i]]=i;
        }
        // 定义内部函数对象
        struct Comparator {
            const unordered_map<char,int>& mep_ref;
            Comparator(const unordered_map<char,int>& map) : mep_ref(map) {}
            bool operator()(const string& a, const string& b) const {
                int n = min(a.size(), b.size());
                for(int i=0;i<n;i++){
                    int diff = mep_ref[a[i]] - mep_ref[b[i]];
                    if(diff != 0){
                        return diff > 0;
                    }
                }
                return a.size() <= b.size();
            }
        };
        vector<string> temp = words;
        sort(temp.begin(), temp.end(), Comparator(mep));
        return temp == words;
    }
};

哪种写法效率更高？ #

lambda表达式和函数对象（Functor）的效率几乎完全一致——编译器会把lambda编译成一个匿名的函数对象，两者都是在编译期就能确定调用逻辑，没有额外的运行时开销。

而静态成员变量的方式反而可能有额外成本：比如每次调用都要清空静态mep，而且静态变量的初始化可能涉及线程安全的开销，更重要的是状态残留的风险容易引发bug。

所以优先选择lambda的写法，既简洁高效，又没有状态污染的问题。

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