C++ C++；如何根据第一个、第二个、第三个对元组进行排序

代码将根据第一个元素和第二个元素（如果第一个元素相等）对std:：pair进行排序

有人能告诉我如何使用元组根据第三个元素进行排序吗？如果第一个和第二个恰好相等

我想知道的是如何使用谓词根据第一个、第二个（如果第一个相等）和第三个（如果第一个和第二个相等）进行排序

例如，如果我有：

(3,2,3)
(1,1,0)
(1,1,1)
(2,2,2)

它将打印：

(1,1,0)
(1,1,1)
(2,2,2)
(3,2,3)

代码：

#包括
#包括
#包括
#包括
typedef std：：配对我的配对；
结构排序\u pred
{
布尔运算符（）（常数我的对&左，常数我的对&右）常数
{
返回（左先<右先）|
（！（right.firstleft.second））；
}
};
int main（）
{
std：：矢量数据；
data.push_back（我的_对（3,2））；
data.push_back（我的_对（1,2））；
data.push_back（我的_对（1，1））；
data.push_back（我的_对（2,2））；
std:：stable_sort（data.begin（）、data.end（）、sort_pred（））；
对于（const auto&p:data）std:：cout
我想知道的是如何使用谓词根据第一个、第二个（如果第一个相等）和第三个（如果第一个和第二个相等）进行排序

std:：tuple
已经有一个
运算符
我想知道的是如何使用谓词根据第一个、第二个（如果第一个相等）和第三个（如果第一个和第二个相等）进行排序

std:：tuple
已经有了一个
操作符，将它们放入
std:：tuple
中，然后调用
std:：sort
？您是否尝试过在没有谓词的情况下对
向量进行排序，并看到发生了什么？…像这样？@tedlynmo同意。听起来这个问题需要细节或清晰性。@user12660947为什么需要谓词“
std:：pair
和
std:：tuple
已经有了
运算符，或者将它们放入
std:：tuple
中，然后调用
std:：sort
？您是否尝试过在没有谓词的情况下对
向量进行排序，并查看会发生什么情况？…就像是这样？@tedlynmo同意。听起来这个问题需要细节或清晰性。@user12660947为什么需要一个谓词吗？
std:：pair
和
std:：tuple
已经有了
operator替代建议：首先使用
std:：tuple
，而不是
std:：tie
@MooingDuck是的，我真的不知道这样做的利弊。
std:：tie
是一个很好的缩写，所以这是一个额外的建议。：）另一个建议：首先使用
std:：tuple
，而不是
std:：tie
@MooingDuck是的，我真的不知道用这种方法或那种方法来做是否有利弊。
std:：tie
是一个很好的缩写，所以这是一个额外的建议。：）
#include <iostream>
#include <vector>
#include <algorithm>
#include <utility>

typedef std::pair<double, double> my_pair;

struct sort_pred
{
    bool operator ()( const my_pair &left, const my_pair &right ) const
    {
        return ( left.first < right.first ) || 
               ( !( right.first < left.first ) && ( right.second > left.second ) );
    }
};

int main()
{
    std::vector<my_pair> data;

    data.push_back( my_pair( 3, 2 ) );
    data.push_back( my_pair( 1, 2 ) );
    data.push_back( my_pair( 1, 1 ) );
    data.push_back( my_pair( 2, 2 ) );

    std::stable_sort( data.begin(), data.end(), sort_pred() );

    for ( const auto &p : data ) std::cout << p.first << ' ' << p.second << std::endl;
}  

[](auto& a, auto& b) { return std::tie(a.f1, a.f2, a.f3) < std::tie(b.f1, b.f2, b.f3); }

auto comp = [](auto& a, auto& b) {
    return
        std::tie(std::get<0>(a), std::get<1>(a), std::get<2>(b))
        <
        std::tie(std::get<0>(b), std::get<1>(b), std::get<2>(a));
};

std::sort(data.begin(), data.end(), comp);

1,1,1
1,1,0
2,2,2
3,2,3

struct sort_pred {
    bool operator ()(const my_tuple& left, const my_tuple& right) const {
        return 
            std::get<0>(left) != std::get<0>(right) ? std::get<0>(left) < std::get<0>(right) :
            std::get<1>(left) != std::get<1>(right) ? std::get<1>(left) < std::get<1>(right) :
            std::get<2>(left) < std::get<2>(right);
    }
};