Bagaimana cara saya mengurutkan vektor pasangan berdasarkan elemen kedua dari pasangan?

Jika saya memiliki vektor pasangan:

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

Apakah ada dan cara mudah untuk mengurutkan daftar dalam urutan yang meningkat berdasarkan elemen kedua dari pasangan?

Saya tahu saya bisa menulis objek fungsi kecil yang akan melakukan pekerjaan, tetapi apakah ada cara untuk menggunakan bagian-bagian STL yang ada dan std::lessmelakukan pekerjaan secara langsung?

EDIT: Saya mengerti bahwa saya bisa menulis fungsi atau kelas terpisah untuk diteruskan ke argumen ketiga untuk mengurutkan. Pertanyaannya adalah apakah saya bisa membuatnya dari barang standar. Saya benar-benar sesuatu yang terlihat seperti:

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

EDIT : menggunakan c ++ 14, solusi terbaik adalah sangat mudah untuk menulis berkat lambdas yang sekarang dapat memiliki parameter tipe auto. Ini adalah solusi favorit saya saat ini

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

Cukup gunakan komparator khusus (ini merupakan argumen ke-3 opsional untuk 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());

Jika Anda menggunakan kompiler C ++ 11, Anda dapat menulis yang sama menggunakan 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 : sebagai tanggapan atas suntingan Anda terhadap pertanyaan Anda, inilah beberapa pemikiran ... jika Anda benar-benar ingin menjadi kreatif dan dapat menggunakan kembali konsep ini banyak, cukup buat templat:

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);
    }
};

maka Anda dapat melakukan ini juga:

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

atau bahkan

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

Meskipun jujur, ini semua sedikit berlebihan, tulis saja fungsi 3 baris dan lakukan dengan itu :-P

Anda dapat menggunakan boost seperti ini:

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

Saya tidak tahu cara standar untuk melakukan ini sama pendek dan ringkasnya, tetapi Anda bisa ambil boost::binditu semua terdiri dari header.

Cukup sederhana, Anda menggunakan fungsi sortir dari algoritma dan menambahkan fungsi bandingkan sendiri

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

Sekarang Anda harus membuat perbandingan berdasarkan pilihan kedua jadi nyatakan Anda "myComparison" sebagai

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

Dengan C ++ 0x kita dapat menggunakan fungsi 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; } );

Dalam contoh ini jenis pengembalian booldideduksi secara implisit.

Lambda mengembalikan tipe

Ketika fungsi lambda memiliki pernyataan tunggal, dan ini adalah pernyataan kembali, kompilator dapat menyimpulkan tipe kembali. Dari C ++ 11, §5.1.2 / 4:

...

• Jika pernyataan majemuk adalah dalam bentuk { return expression ; }, jenis ekspresi yang dikembalikan setelah konversi nilai-ke-nilai (4.1), konversi array-ke-pointer (4.2), dan konversi fungsi-ke-pointer (4.3);
• jika tidak void,.

Untuk secara eksplisit menentukan jenis pengembalian gunakan formulir []() -> Type { }, seperti di:

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; } );

Untuk sesuatu yang dapat digunakan kembali:

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);
    }
};

Anda dapat menggunakannya sebagai

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

atau

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

Anda harus bergantung pada select2nd yang tidak standar

Cobalah menukar elemen pasangan sehingga Anda dapat menggunakannya std::sort()seperti biasa.