我们来观察下面的结构体重载运算符代码：

1. 给set重载<：

   #include <iostream>
   #include <set>
   using namespace std;
   struct Point{
       int x,y;
       bool operator<(const Point &rhs)const{
           if(x==rhs.x){
               return y<rhs.y;
           }else{
               return x<rhs.x;
           }
       }
   };
   int main() {
       int n;
       set<Point> v;
       cin>>n;
       for (int i=0;i<n;i++){
           Point temp;
           cin>>temp.x>>temp.y;
           v.insert(temp);
       }
       for (set<Point>::iterator it=v.begin();it!=v.end();it++){
           cout<<it->x<<" "<<it->y<<endl;
       }
       return 0;
   }
   

2. 给priority_queue重载<：

   #include <iostream>
   #include <queue>
   #include <vector>
   #include <algorithm>
   using namespace std;
   struct node {
       int sum;
       int a;
       int b;
       node() {
         
       }
       node(int osum, int oa, int ob) {
           sum = osum;
           a = oa;
           b = ob;
       }
       bool operator <(const node& rhs) const{
           if (sum!=rhs.sum){
               return rhs.sum<sum;
           }
           return rhs.a<a;
       }
   };
   int A[1005], B[1005];
   priority_queue<node> pq;
   int main() {
       int n;
       cin >> n;
       for (int i = 1; i <= n; i++) {
           cin >> A[i];
       }
       for (int i = 1; i <= n; i++) {
           cin >> B[i];
       }
       sort(A + 1, A + n + 1);
       sort(B + 1, B + n + 1);
       for (int i=1;i<=n;i++){
           pq.push(node(A[i]+B[1],i,1));
       }
       for (int i=1;i<=n;i++){
           node now=pq.top();
           pq.pop();
           cout<<now.sum<<" ";
           if (now.b+1<=n){
               pq.push(node(A[now.a]+B[now.b+1],now.a,now.b+1));
           }
       }
       return 0;
   }

   ?

大家发现没有，一个是a<rhs.a，一个是x<rhs.x，but why？

因为集合默认小于符号就是小于符号（毕竟是红黑树），他每次会取出最小的出来。所以我们给集合重载符号时，要正着来，因为他本身的符号是正的。

同理，因为优先队列默认小于符号就是大于符号（毕竟大根堆），他每次会取出最大的出来。所以我们给优先队列重载符号时，要反着来，因为他本身的符号是反的。

我们给其他有序STL等重载运算符时也要注意这一点，从大到小的，他的“价值观”时反的，从小到大的，他的“价值观”时正的