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

From cppreference.com

Compiler support
Freestanding and hosted
Language
Standard library
Standard library headers
Named requirements
Feature test macros(C++20)
Language support library
Concepts library(C++20)
Diagnostics library
Memory management library
Metaprogramming library(C++11)
General utilities library
Containers library
Iterators library
Ranges library(C++20)
Algorithms library
Strings library
Text processing library
Numerics library
Date and time library
Input/output library
Filesystem library(C++17)
Concurrency support library(C++11)
Execution control library(C++26)
Technical specifications
Symbols index
External libraries

[edit]

Containers library

node-handle (C++17)
Sequence
array (C++11)
vector
vector<bool>
inplace_vector (C++26)
hive (C++26)
deque
forward_list (C++11)
list
Associative
set
multiset
map
multimap
Unordered associative
unordered_set (C++11)
unordered_multiset (C++11)
unordered_map (C++11)
unordered_multimap (C++11)
Adaptors
stack
queue
priority_queue
flat_set (C++23)
flat_multiset (C++23)
flat_map (C++23)
flat_multimap (C++23)
Views
span (C++20)
mdspan (C++23)
Tables
Iterator invalidation
Member function table
Non-member function table

Element access
array::at
array::operator[]
array::front
array::back
array::data
Operations
array::fill
array::swap

Iterators
array::beginarray::cbegin
array::endarray::cend
array::rbeginarray::crbegin
array::rendarray::crend

Capacity
array::empty
array::size
array::max_size

Non-member functions

operator==operator<=> (C++20)
get(std::array)
swap(std::array)
to_array (C++20)

operator|=operator<operator>operator<=operator>=

(until C++20)(until C++20)(until C++20)(until C++20)(until C++20)

Helper classes

tuple_size<std::array>

tuple_element<std::array>

Deduction guides(C++17)

[edit]

Defined in header`<array>`
template<class T,std::size_t N> bool operator==(conststd::array<T, N>& lhs, conststd::array<T, N>& rhs);	(1)	(since C++11) (constexpr since C++20)
template<class T,std::size_t N> bool operator!=(conststd::array<T, N>& lhs, conststd::array<T, N>& rhs);	(2)	(since C++11) (until C++20)
template<class T,std::size_t N> bool operator<(conststd::array<T, N>& lhs, conststd::array<T, N>& rhs);	(3)	(since C++11) (until C++20)
template<class T,std::size_t N> bool operator<=(conststd::array<T, N>& lhs, conststd::array<T, N>& rhs);	(4)	(since C++11) (until C++20)
template<class T,std::size_t N> bool operator>(conststd::array<T, N>& lhs, conststd::array<T, N>& rhs);	(5)	(since C++11) (until C++20)
template<class T,std::size_t N> bool operator>=(conststd::array<T, N>& lhs, conststd::array<T, N>& rhs);	(6)	(since C++11) (until C++20)
template<class T,std::size_t N> constexpr/* see below */ operator<=>(conststd::array<T, N>& lhs, conststd::array<T, N>& rhs);	(7)	(since C++20)

Compares the contents of twoarrays.

Letvalue_type be the value type ofarray (i.e.,typename array::value_type):

1,2) Checks if the contents oflhs andrhs are equal, that is, they have the same number of elements and each element inlhs compares equal with the element inrhs at the same position.

Equivalent to:

returnstd::distance(lhs.begin(), lhs.end()) ==std::distance(rhs.begin(), rhs.end()) &&std::equal(lhs.begin(), lhs.end(), rhs.begin());	(until C++14)
returnstd::equal(lhs.begin(), lhs.end(), rhs.begin(), rhs.end());	(since C++14)

Ifvalue_type is notEqualityComparable, the behavior is undefined.

3-7) Compares the contents oflhs andrhs lexicographically.

3-6) Equivalent toreturnstd::lexicographical_compare(lhs.begin(), lhs.end(),
rhs.begin(), rhs.end());.

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

value_type is notLessThanComparable.
operator< does not establishtotal order.

7) Equivalent toreturnstd::lexicographical_compare_three_way(lhs.begin(), lhs.end(),
rhs.begin(), rhs.end(),
synth-three-way).

The return type is the return type ofsynth-three-way (i.e.,synth-three-way-result <value_type>).

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

T does not modelthree_way_comparable.
operator< is not defined for values of type (possibly const-qualified)value_type.
operator< does not establishtotal order.

The<,<=,>,>=, and!= operators aresynthesized fromoperator<=> andoperator== respectively.

(since C++20)

[edit]Parameters

lhs, rhs - arrays whose contents to compare

[edit]Return value

Operator	lhs andrhs are equal	lhs is lexicographically greater	rhs is lexicographically greater
operator==	true	false
operator!=	false	true
operator<	false	false	true
operator<=	true	false	true
operator>	false	true	false
operator>=	true	true	false
operator<=>	a value equal to0	a value greater then0	a value less than0

[edit]Complexity

Linear in the size of thearray.

[edit]Notes

The relational operators are defined in terms ofvalue_type'soperator<.

(until C++20)

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

operator<=> usesvalue_type'soperator<=> if possible, orvalue_type'soperator< otherwise. Notably, if thevalue_type does not itself provideoperator<=>, but is implicitly convertible to a three-way comparable type, that conversion will be used instead ofoperator<.

(since C++20)

[edit]Example

Run this code

#include <cassert>#include <compare>#include <array> int main(){conststd::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&&"");}