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

Since C++11

Header: <forward_list>

Compares the contents of two forward_lists.

# Declarations

template< class T, class Alloc >
bool operator==( const std::forward_list<T, Alloc>& lhs,
const std::forward_list<T, Alloc>& rhs );

(since C++11)

template< class T, class Alloc >
bool operator!=( const std::forward_list<T, Alloc>& lhs,
const std::forward_list<T, Alloc>& rhs );

(since C++11) (until C++20)

template< class T, class Alloc >
bool operator<( const std::forward_list<T, Alloc>& lhs,
const std::forward_list<T, Alloc>& rhs );

(since C++11) (until C++20)

template< class T, class Alloc >
bool operator<=( const std::forward_list<T, Alloc>& lhs,
const std::forward_list<T, Alloc>& rhs );

(since C++11) (until C++20)

template< class T, class Alloc >
bool operator>( const std::forward_list<T, Alloc>& lhs,
const std::forward_list<T, Alloc>& rhs );

(since C++11) (until C++20)

template< class T, class Alloc >
bool operator>=( const std::forward_list<T, Alloc>& lhs,
const std::forward_list<T, Alloc>& rhs );

(since C++11) (until C++20)

template< class T, class Alloc >
synth-three-way-result<T>
operator<=>( const std::forward_list<T, Alloc>& lhs,
const std::forward_list<T, Alloc>& rhs );

(since C++20)

# Parameters

lhs, rhs: forward_lists whose contents to compare

# Notes

The relational operators are defined in terms of the element type’s operator<.

The relational operators are defined in terms of synth-three-way, which uses operator<=> if possible, or operator< otherwise.

Notably, if the element does not itself provide operator<=>, but is implicitly convertible to a three-way comparable type, that conversion will be used instead of operator<.

# Example

#include <cassert>
#include <compare>
#include <forward_list>
 
int main()
{
    const std::forward_list
        a{1, 2, 3},
        b{1, 2, 3},
        c{7, 8, 9, 10};
 
    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 &&
    "");
}

# Defect reports

DR	Applied to	Behavior as published	Correct behavior
LWG 3431	C++20	operator<=> did not require Tto model three_way_comparable	requires