C++ 为什么可以'；我不能把比较器放在节点内吗？

我正在使用优先级队列解决一个问题。 我打算用以下方式声明我的节点

struct node{
         int x, y, val;
         node(int _x, int _y, int _val){
             x = _x;
             y = _y;
             val = _val;
         }
         bool operator < (const node& rhs) const{
             return val > rhs.val;
         }
     };

struct节点{
int x，y，val；
节点（整数x，整数y，整数val）{
x=x；
y=_y；
val=_val；
}
布尔运算符<（常数节点和rhs）常数{
返回val>rhs.val；
}
};

并按以下方式使用：

priority_queue<node, vector<node>, node> queue;

priority\u队列；

但它不起作用

然后，我换了另一种方式。它起作用了

struct node{
         int x, y, val;
         node(int _x, int _y, int _val){
             x = _x;
             y = _y;
             val = _val;
         }

     };
struct com{
    bool operator () (const node& lhs, const node& rhs) const{
             return lhs.val > rhs.val;
         }
};
priority_queue<node, vector<node>, com> queue;

struct节点{
int x，y，val；
节点（整数x，整数y，整数val）{
x=x；
y=_y；
val=_val；
}
};
结构组件{
布尔运算符（）（常量节点和左侧、常量节点和右侧）常量{
返回lhs.val>rhs.val；
}
};
优先级队列；

我不知道为什么会有不同。任何建议都很好

给出以下答案，我尝试了不同的方法来运行我的代码，它们是有效的：

版本1

struct node{
         int x, y, val;
         node(int _x, int _y, int _val){
             x = _x;
             y = _y;
             val = _val;
         }
         node(){}

        bool operator () (const node& lhs, const node& rhs) const{
         return lhs.val > rhs.val;
     }
 };

priority_queue<node, vector<node>, node> queue;

struct节点{
int x，y，val；
节点（整数x，整数y，整数val）{
x=x；
y=_y；
val=_val；
}
节点（）{}
布尔运算符（）（常量节点和左侧、常量节点和右侧）常量{
返回lhs.val>rhs.val；
}
};
优先级队列；

第2版：

struct node{
         int x, y, val;
         node(int _x, int _y, int _val){
             x = _x;
             y = _y;
             val = _val;
         }
    bool operator < (const node& rhs) const{
         return val > rhs.val;
     }

 };
priority_queue<node, vector<node>, less<node>> queue;
//or
//priority_queue<node, vector<node>> queue;
//or
//priority_queue<node> queue;

struct节点{
int x，y，val；
节点（整数x，整数y，整数val）{
x=x；
y=_y；
val=_val；
}
布尔运算符<（常数节点和rhs）常数{
返回val>rhs.val；
}
};
优先级队列；
//或
//优先级队列；
//或
//优先级队列；

节点

不是默认可构造的，并且它没有

操作符（）

由于您使用的是
操作符
节点
不是默认可构造的，并且它没有
操作符（）

由于您正在使用
操作符，
priority\u队列
在求值过程中会逐字调用
com（arg1，arg2）

该函数需要作为函数对象（在您的示例中是有效的）、静态函数或lambda可用。您的第一个
struct
没有这些。
优先级队列
在其求值过程中字面上调用
com（arg1，arg2）

该函数需要作为函数对象（在您的示例中是有效的）、静态函数或lambda可用。您的第一个
结构
没有这些属性。
在第一种情况下，
节点
本身是一个非比较器-相反，它为
操作符提供重载。在第一种情况下，
节点
本身是一个非比较器-相反，它为
操作符提供重载，因为第三个模板参数只接受compareFunction（objA，objB）格式。默认情况下，它是
class Compare=std:：less
，std:：less调用操作符，因为第三个模板参数只接受compareFunction（objA，objB）格式。默认情况下，它是std:：less调用操作符的
class Compare=std:：less
，因为在您的节点中，它不是定义的
operator（）
。您可以使用
std:：less
使其工作，也可以省略压缩机。您没有注意到
节点
结构中的比较运算符与
com
结构中的函数调用运算符之间有任何区别吗？就像一个是比较运算符，另一个是函数调用运算符一样？在第一个示例中，您不需要额外的模板参数，因为随后将使用默认的
std:：less
来使用
，因为在您的节点中，它不是定义的
operator（）
。您可以使用
std:：less
使其工作，也可以省略压缩机。您没有注意到
节点
结构中的比较运算符与
com
结构中的函数调用运算符之间有任何区别吗？就像一个是比较运算符，另一个是函数调用运算符一样？在第一个示例中，您不需要额外的模板参数，因为这样将使用默认的
std:：less
来使用

priority_queue<node, vector<node>, less<node>> queue; 
// same as
priority_queue<node, vector<node>> queue;
// also same as
priority_queue<node> queue;

priority_queue<node, vector<node>> queue;

cmp(x,y)

x < y

std::priority_queue<node, std::vector<node>> queue;