Làm cách nào để sắp xếp một vectơ các cặp dựa trên phần tử thứ hai của cặp?

Nếu tôi có một vectơ cặp:

std::vector<std::pair<int, int> > vec;

Có cách nào dễ dàng để sắp xếp danh sách theo thứ tự tăng dần dựa trên yếu tố thứ hai của cặp không?

Tôi biết tôi có thể viết một đối tượng hàm nhỏ sẽ thực hiện công việc, nhưng có cách nào để sử dụng các phần hiện có của STL và std::lessthực hiện công việc trực tiếp không?

EDIT: Tôi hiểu rằng tôi có thể viết một hàm hoặc lớp riêng biệt để chuyển đến đối số thứ ba để sắp xếp. Câu hỏi là liệu tôi có thể xây dựng nó từ những thứ tiêu chuẩn hay không. Tôi thực sự muốn một cái gì đó trông giống như:

std::sort(vec.begin(), vec.end(), std::something_magic<int, int, std::less>());

EDIT : sử dụng c ++ 14, giải pháp tốt nhất là rất dễ viết nhờ lambdas hiện có thể có các tham số về loại auto. Đây là giải pháp yêu thích hiện tại của tôi

std::sort(v.begin(), v.end(), [](auto &left, auto &right) {
    return left.second < right.second;
});

Chỉ cần sử dụng một bộ so sánh tùy chỉnh (đó là đối số thứ 3 tùy chọn std::sort)

struct sort_pred {
    bool operator()(const std::pair<int,int> &left, const std::pair<int,int> &right) {
        return left.second < right.second;
    }
};

std::sort(v.begin(), v.end(), sort_pred());

Nếu bạn đang sử dụng trình biên dịch C ++ 11, bạn có thể viết tương tự bằng lambdas:

std::sort(v.begin(), v.end(), [](const std::pair<int,int> &left, const std::pair<int,int> &right) {
    return left.second < right.second;
});

EDIT : để trả lời các chỉnh sửa của bạn cho câu hỏi của bạn, đây là một số suy nghĩ ... nếu bạn thực sự muốn sáng tạo và có thể sử dụng lại khái niệm này rất nhiều, chỉ cần tạo một mẫu:

template <class T1, class T2, class Pred = std::less<T2> >
struct sort_pair_second {
    bool operator()(const std::pair<T1,T2>&left, const std::pair<T1,T2>&right) {
        Pred p;
        return p(left.second, right.second);
    }
};

sau đó bạn cũng có thể làm điều này:

std::sort(v.begin(), v.end(), sort_pair_second<int, int>());

hoặc thậm chí

std::sort(v.begin(), v.end(), sort_pair_second<int, int, std::greater<int> >());

Mặc dù thành thật mà nói, đây là một chút quá mức cần thiết, chỉ cần viết hàm 3 dòng và được thực hiện với nó :-P

Bạn có thể sử dụng boost như thế này:

std::sort(a.begin(), a.end(), 
          boost::bind(&std::pair<int, int>::second, _1) <
          boost::bind(&std::pair<int, int>::second, _2));

Tôi không biết một cách tiêu chuẩn để làm điều này ngắn và ngắn gọn như nhau, nhưng bạn có thể lấy boost::bindtất cả bao gồm các tiêu đề.

Rất đơn giản, bạn sử dụng hàm sắp xếp từ thuật toán và thêm chức năng so sánh của riêng bạn

vector< pair<int,int > > v;
sort(v.begin(),v.end(),myComparison);

Bây giờ bạn phải thực hiện so sánh dựa trên lựa chọn thứ hai để khai báo bạn là "myComparison" là

bool myComparison(const pair<int,int> &a,const pair<int,int> &b)
{
       return a.second<b.second;
}

Với C ++ 0x, chúng ta có thể sử dụng các hàm lambda:

using namespace std;
vector<pair<int, int>> v;
        .
        .
sort(v.begin(), v.end(),
     [](const pair<int, int>& lhs, const pair<int, int>& rhs) {
             return lhs.second < rhs.second; } );

Trong ví dụ này, kiểu trả về boolđược suy diễn ngầm.

Các loại trả lại Lambda

Khi hàm lambda có một câu lệnh đơn và đây là câu lệnh return, trình biên dịch có thể suy ra kiểu trả về. Từ C ++ 11, §5.1.2 / 4:

...

• Nếu câu lệnh ghép có dạng biểu thức { return expression ; }được trả về sau khi chuyển đổi lvalue-to-rvalue (4.1), chuyển đổi mảng thành con trỏ (4.2) và chuyển đổi hàm thành con trỏ (4.3);
• nếu không void.

Để chỉ định rõ ràng kiểu trả về, hãy sử dụng biểu mẫu []() -> Type { }, như trong:

sort(v.begin(), v.end(),
     [](const pair<int, int>& lhs, const pair<int, int>& rhs) -> bool {
             if (lhs.second == 0)
                 return true;
             return lhs.second < rhs.second; } );

Đối với một cái gì đó có thể tái sử dụng:

template<template <typename> class P = std::less >
struct compare_pair_second {
    template<class T1, class T2> bool operator()(const std::pair<T1, T2>& left, const std::pair<T1, T2>& right) {
        return P<T2>()(left.second, right.second);
    }
};

Bạn có thể sử dụng nó như

std::sort(foo.begin(), foo.end(), compare_pair_second<>());

hoặc là

std::sort(foo.begin(), foo.end(), compare_pair_second<std::less>());

Bạn sẽ phải dựa vào select2nd không chuẩn

Hãy thử hoán đổi các yếu tố của các cặp để bạn có thể sử dụng std::sort()như bình thường.