A RetroSearch Logo

Home - News ( United States | United Kingdom | Italy | Germany ) - Football scores

Search Query:

Showing content from https://en.cppreference.com/w/cpp/language/../keywords/../container/array/operator_cmp.html below:

operator==,!=,<,<=,>,>=,<=>(std::array) - cppreference.com

(1) (since C++11)
(constexpr since C++20) (2) (since C++11)
(until C++20) (3) (since C++11)
(until C++20) (4) (since C++11)
(until C++20) (5) (since C++11)
(until C++20) (6) (since C++11)
(until C++20) (7) (since C++20)

Compares the contents of two arrays.

Let value_type be the value type of array (i.e., typename array::value_type):

1,2) Checks if the contents of lhs and rhs are equal, that is, they have the same number of elements and each element in lhs compares equal with the element in rhs at the same position.

Equivalent to:

return std::distance(lhs.begin(), lhs.end())
               == std::distance(rhs.begin(), rhs.end())
           && std::equal(lhs.begin(), lhs.end(), rhs.begin());

(until C++14)

return std::equal(lhs.begin(), lhs.end(), rhs.begin(), rhs.end());

(since C++14)

3-7) Compares the contents of lhs and rhs lexicographically.

If any of the following conditions is satisfied, the behavior is undefined:

If any of the following conditions is satisfied, the behavior is undefined:

The <, <=, >, >=, and != operators are synthesized from operator<=> and operator== respectively.

(since C++20) [edit] Parameters lhs, rhs - arrays whose contents to compare [edit] Return value Operator lhs and rhs
are equal lhs is
 lexicographically greater  rhs is
 lexicographically greater  operator== true false operator!= false true operator< false false true operator<= true operator> false true false operator>= true  operator<=>   a value equal to ​0​  a value greater then ​0​ a value less than ​0​ [edit] Complexity

Linear in the size of the array.

[edit] Notes

The relational operators are defined in terms of value_type's operator<.

(until C++20)

The relational operators are not defined. The rewritten candidate operator<=> will be selected by overload resolution.

operator<=> uses value_type's operator<=> if possible, or value_type's operator< otherwise. Notably, if the value_type does not itself provide operator<=>, but is implicitly convertible to a three-way comparable type, that conversion will be used instead of operator<.

(since C++20) [edit] Example 
#include <cassert>
#include <compare>
#include <array>
 
int main()
{
    const std::array
        a{1, 2, 3},
        b{1, 2, 3},
        c{7, 8, 9};
 
    assert
    (""
        "Compare equal containers:" &&
        (a != b) == false &&
        (a == b) == true &&
        (a < b) == false &&
        (a <= b) == true &&
        (a > b) == false &&
        (a >= b) == true &&
        (a <=> b) != std::weak_ordering::less &&
        (a <=> b) != std::weak_ordering::greater &&
        (a <=> b) == std::weak_ordering::equivalent &&
        (a <=> b) >= 0 &&
        (a <=> b) <= 0 &&
        (a <=> b) == 0 &&
 
        "Compare non equal containers:" &&
        (a != c) == true &&
        (a == c) == false &&
        (a < c) == true &&
        (a <= c) == true &&
        (a > c) == false &&
        (a >= c) == false &&
        (a <=> c) == std::weak_ordering::less &&
        (a <=> c) != std::weak_ordering::equivalent &&
        (a <=> c) != std::weak_ordering::greater &&
        (a <=> c) < 0 &&
        (a <=> c) != 0 &&
        (a <=> c) <= 0 &&
    "");
}
[edit] Defect reports

The following behavior-changing defect reports were applied retroactively to previously published C++ standards.

RetroSearch is an open source project built by @garambo | Open a GitHub Issue

Search and Browse the WWW like it's 1997 | Search results from DuckDuckGo

HTML: 3.2 | Encoding: UTF-8 | Version: 0.7.4