Inequality operators

Synopses

Declared in <bslstl_function.h>

Return true if lhs and rhs are not equal.

template<
    class t_HEAD,
    class... t_TAIL>
bool
operator!=(
    variant<t_HEAD, t_TAIL...> const& lhs,
    variant<t_HEAD, t_TAIL...> const& rhs);

» more...

Return true if the specified hash multimaps do not contain the same elements.

template<
    class _Key,
    class _Tp,
    class _HashFcn,
    class _EqlKey,
    class _Alloc>
bool
operator!=(
    hash_multimap<_Key, _Tp, _HashFcn, _EqlKey, _Alloc> const& __hm1,
    hash_multimap<_Key, _Tp, _HashFcn, _EqlKey, _Alloc> const& __hm2);

» more...

Return true if the specified hash maps do not contain the same elements.

template<
    class _Key,
    class _Tp,
    class _HashFcn,
    class _EqlKey,
    class _Alloc>
bool
operator!=(
    hash_map<_Key, _Tp, _HashFcn, _EqlKey, _Alloc> const& __hm1,
    hash_map<_Key, _Tp, _HashFcn, _EqlKey, _Alloc> const& __hm2);

» more...

Return true if the specified lists do not contain the same elements.

template<
    class _Tp,
    class _Alloc>
bool
operator!=(
    slist<_Tp, _Alloc> const& __x,
    slist<_Tp, _Alloc> const& __y);

» more...

Return true if the specified hash multisets do not contain the same elements.

template<
    class _Value,
    class _HashFcn,
    class _EqualKey,
    class _Alloc>
bool
operator!=(
    hash_multiset<_Value, _HashFcn, _EqualKey, _Alloc> const& __hm1,
    hash_multiset<_Value, _HashFcn, _EqualKey, _Alloc> const& __hm2);

» more...

Return true if the specified hash sets do not contain the same elements.

template<
    class _Value,
    class _HashFcn,
    class _EqualKey,
    class _Alloc>
bool
operator!=(
    hash_set<_Value, _HashFcn, _EqualKey, _Alloc> const& __hm1,
    hash_set<_Value, _HashFcn, _EqualKey, _Alloc> const& __hm2);

» more...

Return true if the specified hash tables do not contain the same elements.

template<
    class _Val,
    class _Key,
    class _HF,
    class _ExK,
    class _EqK,
    class _All>
bool
operator!=(
    hashtable<_Val, _Key, _HF, _ExK, _EqK, _All> const& __hm1,
    hashtable<_Val, _Key, _HF, _ExK, _EqK, _All> const& __hm2);

» more...

Return whether two hashtable iterators differ.

template<
    class _Val,
    class _Key,
    class _HF,
    class _ExK,
    class _EqK,
    class _All>
bool
operator!=(
    _Hashtable_iterator<_Val, _Key, _HF, _ExK, _EqK, _All> const& __x,
    _Hashtable_iterator<_Val, _Key, _HF, _ExK, _EqK, _All> const& __y);

» more...

Return true if lhs and rhs do not have the same value.

template<
    class VALUE,
    class CONTAINER>
bool
operator!=(
    queue<VALUE, CONTAINER> const& lhs,
    queue<VALUE, CONTAINER> const& rhs);

» more...

Return whether the specified queues do not have the same value; see the non‐member operator!= in the bsl namespace.

bool
operator!=(
    queue<VALUE2, CONTAINER2> const& lhs,
    queue<VALUE2, CONTAINER2> const& rhs);

» more...

Return true if the specified function is not empty.

template<class PROTOTYPE>
bool
operator!=(
    function<PROTOTYPE> const& f,
    nullptr_t unused) noexcept;

» more...

Return whether the operands do not have the same value.

template<
    class VALUE,
    class CONTAINER>
bool
operator!=(
    stack<VALUE, CONTAINER> const& lhs,
    stack<VALUE, CONTAINER> const& rhs);

» more...

Return whether two stacks have different values.

bool
operator!=(
    stack<VAL, CONT> const& lhs,
    stack<VAL, CONT> const& rhs);

» more...

Compare a std::optional with a bsl::optional for inequality.

template<
    class t_LHS_TYPE,
    class t_RHS_TYPE>
constexpr
bool
operator!=(
    std::optional<t_LHS_TYPE> const& lhs,
    bsl::optional<t_RHS_TYPE> const& rhs);

» more...

Return whether the operands do not have the same value.

template<
    class t_LHS_TYPE,
    class t_RHS_TYPE>
constexpr
bool
operator!=(
    bsl::optional<t_LHS_TYPE> const& lhs,
    std::optional<t_RHS_TYPE> const& rhs);

» more...

Compare an optional object with a value for inequality.

template<
    class t_LHS_TYPE,
    class t_RHS_TYPE>
constexpr
bool
operator!=(
    t_LHS_TYPE const& lhs,
    bsl::optional<t_RHS_TYPE> const& rhs);

» more...

Return whether the operands do not have the same value.

template<
    class t_LHS_TYPE,
    class t_RHS_TYPE>
constexpr
bool
operator!=(
    bsl::optional<t_LHS_TYPE> const& lhs,
    t_RHS_TYPE const& rhs);

» more...

Return whether the operands do not have the same value.

template<
    class t_LHS_TYPE,
    class t_RHS_TYPE>
constexpr
bool
operator!=(
    bsl::optional<t_LHS_TYPE> const& lhs,
    bsl::optional<t_RHS_TYPE> const& rhs);

» more...

Return true if the specified function is not empty.

template<class PROTOTYPE>
bool
operator!=(
    nullptr_t unused,
    function<PROTOTYPE> const& f) noexcept;

» more...

Return Value

  • true if lhs and rhs are not equal

  • true if the hash multimaps do not contain the same elements

  • true if the hash maps do not contain the same elements

  • true if the lists differ, and false otherwise

  • true if the hash multisets do not contain the same elements

  • true if the hash sets do not contain the same elements

  • true if the hash tables do not contain the same elements

  • true if the iterators refer to different nodes

  • true if the queues differ, otherwise false

  • true if f is not empty, and false otherwise

  • true if the stacks differ, false otherwise

  • true if lhs and rhs do not have the same value, and false otherwise

Parameters

Name

Description

lhs

variant to compare

rhs

variant to compare

__hm1

first hash multimap

__hm2

second hash multimap

__x

left‐hand list

__y

right‐hand list

f

function object to compare with null

unused

null pointer literal

Created with MrDocs