C++ 根据比较函数C+对一组对进行排序+；

我试图对数组进行排序，如果（I.first>j.first）那么

I

首先出现，

如果（I.first==j.first）

那么

I.second

必须小于

j.second

为了排在第一位，这是我写的函数，但它似乎不起作用

#include <stdio.h>
#include <utility>
#include <algorithm>

using namespace std;

bool cmp(pair<int,int> i, pair<int,int> j) {
    if(i.first > j.first)
        return i<j;
    else if (i.first == j.first) {
        if(i.second > j.second)
            return i < j;
        else
            return j<i;
    }
    else
        return j<i;
}

int main(int argc, char **argv)
{
    pair<int,int> arr[4];
    arr[0]=make_pair<int,int>(3,7);
    arr[1]=make_pair<int,int>(2,5);
    arr[2]=make_pair<int,int>(3,4);
    arr[3]=make_pair<int,int>(1,8);
    sort(arr,arr+3,cmp);
    for (int i=0;i<4;i++)
    {
        printf("element (%d,%d)\n",get<0>(arr[i]),get<1>(arr[i]));
    }
}

有什么想法吗？感谢阅读

这应该可以：

bool cmp(pair<int,int> i, pair<int,int> j)
{
    if( i.first == j.first ) 
        return i.second < j.second;
    return i.first > j.first;
}

bool cmp（对i，对j）
{
如果（i.first==j.first）
返回i.secondj.first；
}

这应该可以：

bool cmp(pair<int,int> i, pair<int,int> j)
{
    if( i.first == j.first ) 
        return i.second < j.second;
    return i.first > j.first;
}

bool cmp（对i，对j）
{
如果（i.first==j.first）
返回i.secondj.first；
}
bool cmp（标准：：对i，标准：：对j）
{
如果（i.first>j.first）
{
//现在i大于j，所以只要：
返回true；
}
//你回来了，所以你只有在不符合条件的情况下才能到这里；
一些人还考虑使用其他糟糕的款式…
else如果（i.first==j.first）
{
//永远不要使用if（条件）返回true；否则返回false；
//刚做：返回条件；
//因此：
返回i.second>j.second；
}
其他的
{
返回false；
}
}

您可以稍微缩短一点：

bool greater(std::pair<int, int> i, std::pair<int, int> j)
{
    if(i.first == j.first)
    {
        return i.second < j.second;
    }
    return i.first > j.first;
}

bool更大（标准：：对i，标准：：对j）
{
如果（i.first==j.first）
{
返回i.secondj.first；
}

甚至作为一个班轮：

return i.first == j.first ? i.second < j.second : i.first > j.first;

返回i.first==j.first？i、 第二次j.first；

最后，您还可以使用lambda（如果您仅在一个位置按此特定顺序排序）：

std:：sort
(
a、 a+n，
[]（标准：：对i，标准：：对j）
{
返回i.first==j.first？i.secondj.first；
}
);

在解释原始代码的最后：

if(i.first > j.first)
    // std::pair's comparison operator will exactly do the analog
    // stuff you INTENDED to do, but now, as the "first"s already
    // compare greater, i < j will return just the opposite,
    // i. e. false(!!!)
    return i < j;

if（i.first>j.first）
//std:：pair的比较运算符将精确执行模拟
//你想做的事，但现在，作为第一个
//比较大，i

与所有其他比较类似，因此您的it相当于：

bool cmp(std::pair<int, int>, std::pair<int, int>)
{
    return false;
}

boolcmp（std:：pair，std:：pair）
{
返回false；
}
bool cmp（标准：：对i，标准：：对j）
{
如果（i.first>j.first）
{
//现在i大于j，所以只要：
返回true；
}
//你回来了，所以你只有在不符合条件的情况下才能到这里；
一些人还考虑使用其他糟糕的款式…
else如果（i.first==j.first）
{
//永远不要使用if（条件）返回true；否则返回false；
//刚做：返回条件；
//因此：
返回i.second>j.second；
}
其他的
{
返回false；
}
}

您可以稍微缩短一点：

bool greater(std::pair<int, int> i, std::pair<int, int> j)
{
    if(i.first == j.first)
    {
        return i.second < j.second;
    }
    return i.first > j.first;
}

bool更大（标准：：对i，标准：：对j）
{
如果（i.first==j.first）
{
返回i.secondj.first；
}

甚至作为一个班轮：

return i.first == j.first ? i.second < j.second : i.first > j.first;

返回i.first==j.first？i、 第二次j.first；

最后，您还可以使用lambda（如果您仅在一个位置按此特定顺序排序）：

std:：sort
(
a、 a+n，
[]（标准：：对i，标准：：对j）
{
返回i.first==j.first？i.secondj.first；
}
);

在解释原始代码的最后：

if(i.first > j.first)
    // std::pair's comparison operator will exactly do the analog
    // stuff you INTENDED to do, but now, as the "first"s already
    // compare greater, i < j will return just the opposite,
    // i. e. false(!!!)
    return i < j;

if（i.first>j.first）
//std:：pair的比较运算符将精确执行模拟
//你想做的事，但现在，作为第一个
//比较大，i

与所有其他比较类似，因此您的it相当于：

bool cmp(std::pair<int, int>, std::pair<int, int>)
{
    return false;
}

boolcmp（std:：pair，std:：pair）
{
返回false；
}
您可能依赖于对/元组的默认顺序，因此调整您的输入：

bool cmp(pair<int,int> lhs, pair<int,int> rhs) {
    return std::make_pair(-lhs.first, lhs.second)
         < std::make_pair(-rhs.first, rhs.second);
}

bool cmp（左对、右对）{
返回std：：生成_对（-lhs第一，lhs第二）

或

bool cmp（左对、右对）{
返回标准：：连接（右侧第一，左侧第二）
您可能依赖于对/元组的默认顺序，因此调整您的输入：

bool cmp(pair<int,int> lhs, pair<int,int> rhs) {
    return std::make_pair(-lhs.first, lhs.second)
         < std::make_pair(-rhs.first, rhs.second);
}

bool cmp（左对、右对）{
返回std：：生成_对（-lhs第一，lhs第二）

或

bool cmp（左对、右对）{
返回标准：：连接（右侧第一，左侧第二）
在这个混乱的函数中，你想做什么？看起来像一组随机变量statements@Slava我试图对它们进行排序，如果i.first>j.first，那么我在数组中是第一位的，如果i.first==j.first，那么它在i.second和j.second之间进行比较，如果i.secondj.first，那么我在数组中是第一位的，如果i.first==j.first，那么它在i.second和j.second之间进行比较，如果i.secondi>j
即可工作。这是我第一次使用比较函数进行排序，这使概念对我来说更加清楚，谢谢你，你把第二个条件搞错了，如果是这样的话，
i>j
就行了