Namensräume
Varianten

    operator==,!=,<,<=,>,>=(std::pair)

    Aus cppreference.com
    See More

    This page has been machine-translated from the English version of the wiki using Google Translate.

    The translation may contain errors and awkward wording. Hover over text to see the original version. You can help to fix errors and improve the translation. For instructions click here.

    Click here for the English version of this page

    <metanoindex/>

     
    C++
     
    Utilities-Bibliothek
     
    std::pair
    Member-Funktionen
    Original:
    Member functions
    The text has been machine-translated via Google Translate.
    You can help to correct and verify the translation. Click here for instructions.
    pair::pair
    pair::operator=
    pair::swap
    Non-Member-Funktionen
    Original:
    Non-member functions
    The text has been machine-translated via Google Translate.
    You can help to correct and verify the translation. Click here for instructions.
    make_pair
    operator=
    operator!=
    operator<
    operator<=
    operator>
    operator>=
    std::swap
    get(C++11)
    Helper-Klassen
    Original:
    Helper classes
    The text has been machine-translated via Google Translate.
    You can help to correct and verify the translation. Click here for instructions.
    tuple_size(C++11)
    tuple_element(C++11)
     
    <tbody> </tbody>
    definiert in Header <utility>
    template< class T1, class T2 > bool operator==( const pair<T1,T2>& lhs, const pair<T1,T2>& rhs );
    		 (1)
    template< class T1, class T2 > bool operator!=( const pair<T1,T2>& lhs, const pair<T1,T2>& rhs );
    		 (2)
    template< class T1, class T2 > bool operator<( const pair<T1,T2>& lhs, const pair<T1,T2>& rhs );
    		 (3)
    template< class T1, class T2 > bool operator<=( const pair<T1,T2>& lhs, const pair<T1,T2>& rhs );
    		 (4)
    template< class T1, class T2 > bool operator>( const pair<T1,T2>& lhs, const pair<T1,T2>& rhs );
    		 (5)
    template< class T1, class T2 > bool operator>=( const pair<T1,T2>& lhs, const pair<T1,T2>& rhs );
    		 (6)

    1-2) Tests if both elements of lhs and rhs are equal, that is, compares lhs.first with rhs.first and lhs.second with rhs.second

    3-6) Compares lhs and rhs lexicographically, that is, compares the first elements and only if they are equivalent, compares the second elements.

    Parameter

    lhs, rhs - pairs to compare

    Rückgabewert

    1) true if both lhs.first == rhs.first and lhs.second == rhs.second, otherwise false

    2) true if either lhs.first != rhs.first or lhs.second != rhs.second, otherwise false

    3) If lhs.first<rhs.first, returns true. Otherwise, if rhs.first<lhs.first, returns false. Otherwise, if lhs.second<rhs.second, returns true. Otherwise, returns false.

    4) !(rhs < lhs)

    5) rhs < lhs

    6) !(lhs < rhs)

    Beispiel

    Because operator< is defined for pairs, containers of pairs can be sorted. 

    #include <iostream>
#include <utility>
#include <vector>
#include <algorithm>

int main()
{
    std::vector<std::pair<int, std::string>> v = { {2, "baz"},
                                                   {2, "bar"},
                                                   {1, "foo"} };
    std::sort(v.begin(), v.end());

    for(auto p: v) {
        std::cout << "(" << p.first << "," << p.second << ")\n";
    }
}

    Output: 

    (1,foo)
(2,bar)
(2,baz)