Namensräume
Varianten
Aktionen

std::experimental::ranges::not_equal_to

Von cppreference.com
< cpp‎ | experimental‎ | ranges
 
 
 
 
Allgemeine Dienstprogramme-Bibliothek
Hilfskomponenten
Funktionsobjekte
not_equal_to
Metaprogrammierung und Typ-Traits
Getaggte Paare und Tupel
                          
Tag-Spezifizierer
                                      
                          
 
template< class T = void >

    erfordert EqualityComparable<T> ||
             Same<T, void> ||
             /* == für zwei const T lvalues ruft einen eingebauten Operator auf, der Zeiger vergleicht */

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

Funktionsobjekt für Vergleiche. Die primäre Vorlage ruft operator == für const lvalues vom Typ T auf und negiert das Ergebnis. Die Spezialisierung not_equal_to<void> leitet die Parametertypen des Funktionsaufrufoperators aus den Argumenten ab (nicht aber den Rückgabetyp).

Alle Spezialisierungen von not_equal_to sind Semiregular.

Inhalt

[bearbeiten] Member types

Mitgliedertyp Definition
is_transparent (nur Mitglied der Spezialisierung not_equal_to<void>) /* nicht spezifiziert */

[bearbeiten] Member functions

operator()
prüft, ob die Argumente *nicht gleich* sind.
(öffentliche Memberfunktion)

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

constexpr bool operator()(const T& x, const T& y) const;
(1) (nur Mitglied der primären Vorlage not_equal_to<T>)
template< class T, class U >

    erfordert EqualityComparableWith<T, U> ||
             /* std::declval<T>() == std::declval<U>() wird aufgelöst zu
               einem eingebauten Operator, der Zeiger vergleicht */

constexpr bool operator()(T&& t, U&& u) const;
(2) (nur Mitglied der Spezialisierung not_equal_to<void>)
1) Vergleicht x und y. Äquivalent zu return !ranges::equal_to<>{}(x, y);.
2) Vergleicht t und u. Äquivalent zu return !ranges::equal_to<>{}(std::forward<T>(t), std::forward<U>(u));.

[bearbeiten] Notes

Im Gegensatz zu std::not_equal_to erfordert ranges::not_equal_to, dass sowohl == als auch != gültig sind (über die EqualityComparable und EqualityComparableWith Constraints) und ist vollständig in Bezug auf ranges::equal_to definiert. Die Implementierung kann jedoch operator!= direkt verwenden, da diese Konzepte die Konsistenz der Ergebnisse von == und != erfordern.

[bearbeiten] Example

[bearbeiten] See also

Funktions-Objekt, das x != y implementiert
(Klassen-Template) [bearbeiten]