Make your comparator function static. It will work.

要调用compare，你需要一个Field对象。如果你有C++11支持，你可以使用lambda从那里调用它：

sort(vec.begin(), vec.end(), [this] (vector<int> a, vector<int> b) {
    return compare(a, b); });

或者只是将比较方法移出类，反正你也不需要访问它的成员。

有三种方法可以做到这一点：
1.使用为结构定义的operator（）创建结构
结构比较函数{

inline bool operator() (const vector<int> &a, const vector<int> &b)
 {
     return (a.back() < b.back());
 }

};
并以下面的方式在排序函数调用中：
标准：：排序（向量开始（）、向量结束（）、比较函数（））;
1.如果你使用的是C++11版本，那么编写你的lamda函数并调用类中定义的comparator函数：

std::sort(vec.begin(), vec.end(), [this](vector<int> a, vector<int> b){
             return (compareFun(a,b));

}）;
按照下面提到的方式在类中定义compareFun：
类测试{public：bool compareFun（向量a，向量b）{返回（a.返回（）〈b.返回（））; }};
1.使用静态方法，正如我们的一个朋友提到的。我希望这工作。

class Test {
    private:
        vector< vector<int> > mat;
        bool compare(vector<int>, vector<int>);
    public:
        void sortMatrix();
}

static bool Field::compare( vector<int> a, vector<int> b) {
    return (a.back() < b.back());
}

void Test::sortMatrix() {
    sort(vec.begin(), vec.end(), compare);
}

这个错误清楚地表明你正在试图访问一个非静态成员，所以，只要把它转换成静态的就行了。

你可以通过在比较器排序函数前添加“static”关键字来解决这个问题。

class Solution {
public:
    
     static bool sortby_sec(const pair<int,int>&a,const pair<int,int>&b)
            {
                return (a.second<b.second); 
             }
       
    int maximumUnits(vector<vector<int>>& b, int tr) {
        vector<pair<int,int>>vp;
        for(int i=0;i<b.size();++i)
        {
            vp.push_back(make_pair(b[i][0],b[i][1]));
        }
        sort(vp.begin(),vp.end(),sortby_sec);
        
        int ms=0;
        for(int i=vp.size()-1;i>=0;i--)
        {
             if(tr>vp[i].first)
             {
                 tr-=vp[i].first;
                 ms=ms+vp[i].first*vp[i].second;
             }
              else{
                 ms=ms+tr*vp[i].second;
                  break;

              }
          }
        
       return ms; 
    }
};

将“compare”函数设置为static，因为sort（）函数接受静态函数指针作为参数。

static bool compare(vector<int>, vector<int>);

你遇到这个问题是因为你试图访问函数中的非静态访问成员，只是试图改变你的比较器。你可以使用下面的代码作为参考。

class Test{
    public:
        static bool comp(const vector<int> &a, const vector<int> &b){
        return a[1] < b[1];
    }
    int Intervals(vector<vector<int>>& nums) {
        sort(nums.begin(), nums.end(), comp);
        int count = 0,j=0;
        for(int i = 1; i < nums.size(); i++){
            if(nums[j][1] > nums[i][0])
                count++, j=i; 
            }

       return count;
        }
    };

你可以在比较函数之前使用static。
因为

1. sort函数只接受静态函数作为参数
   1.因为非静态成员函数有一个隐式的第一个参数，这就是它们访问其他成员的方式。
   如果你想在类外调用comp函数，那么你可以这样写代码

a.comp(b,c)

因此，这被视为3个参数，而不是2个参数。

排序代码在类之外，必须使用上面的语法。

将成员设置为静态将允许以下调用：

Test::comp(b,c)

它只有2个参数，并且与 predicate std：：sort期望的匹配。