Namespaces
Variants

std::experimental::ranges:: not_equal_to

From cppreference.net
Definido en el encabezado <experimental/ranges/functional>
template < class T = void >

requires EqualityComparable < T > ||
Same < T, void > ||
/* == on two const T lvalues invokes a built-in operator comparing pointers */

struct not_equal_to ;
(ranges TS)
template <>
struct not_equal_to < void > ;
(ranges TS)

Objeto función para realizar comparaciones. La plantilla principal invoca operator == en lvalues const de tipo T y niega el resultado. La especialización not_equal_to<void> deduce los tipos de parámetros del operador de llamada a función de los argumentos (pero no el tipo de retorno).

Todas las especializaciones de not_equal_to son Semiregular .

Contenidos

Tipos de miembros

Tipo de miembro Definición
is_transparent (miembro solo de la especialización not_equal_to<void> ) /* no especificado */

Funciones miembro

operator()
verifica si los argumentos son no iguales
(función miembro pública)

std::experimental::ranges::not_equal_to:: operator()

constexpr bool operator ( ) ( const T & x, const T & y ) const ;
(1) (miembro solo de la plantilla primaria not_equal_to<T> )
template < class T, class U >

requires EqualityComparableWith < T, U > ||
/* std::declval<T>() == std::declval<U>() se resuelve a
un operador incorporado que compara punteros */

constexpr bool operator ( ) ( T && t, U && u ) const ;
(2) (miembro solo de la especialización not_equal_to<void> )
1) Compara x y y . Equivalente a return ! ranges:: equal_to <> { } ( x, y ) ; .
2) Compara t y u . Equivalente a return ! ranges:: equal_to <> { } ( std:: forward < T > ( t ) , std:: forward < U > ( u ) ) ; .

Notas

A diferencia de std::not_equal_to , ranges::not_equal_to requiere que tanto == como != sean válidos (a través de las restricciones EqualityComparable y EqualityComparableWith ), y está completamente definido en términos de ranges::equal_to . Sin embargo, la implementación es libre de usar operator ! = directamente, porque esos conceptos requieren que los resultados de == y != sean consistentes.

Ejemplo

Véase también

objeto función que implementa x ! = y
(plantilla de clase)