Namespaces
Variants

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

    Von de.cppreference.net
     
    C++
     
    Numerikbibliothek
     
    std::valarray
    Mitgliedsfunktionen
    Nicht-Mitgliedsfunktionen
    Hilfsklassen
    Deduktionsregeln (C++17)
     
    Definiert in Header <valarray> 
    template< class T > 
std::valarray<bool> operator==( const std::valarray<T>& lhs, const std::valarray<T>& rhs );
template< class T > 
std::valarray<bool> operator!=( const std::valarray<T>& lhs, const std::valarray<T>& rhs );
template< class T > 
std::valarray<bool> operator< ( const std::valarray<T>& lhs, const std::valarray<T>& rhs );
template< class T > 
std::valarray<bool> operator<=( const std::valarray<T>& lhs, const std::valarray<T>& rhs );
template< class T > 
std::valarray<bool> operator> ( const std::valarray<T>& lhs, const std::valarray<T>& rhs );
template< class T > 
std::valarray<bool> operator>=( const std::valarray<T>& lhs, const std::valarray<T>& rhs );
    		(1) 
    template< class T > 
std::valarray<bool> operator==( const typename std::valarray<T>::value_type & lhsv,
                                const std::valarray<T>& rhs );
template< class T > 
std::valarray<bool> operator!=( const typename std::valarray<T>::value_type & lhsv,
                                const std::valarray<T>& rhs );
template< class T > 
std::valarray<bool> operator< ( const typename std::valarray<T>::value_type & lhsv,
                                const std::valarray<T>& rhs );
template< class T > 
std::valarray<bool> operator<=( const typename std::valarray<T>::value_type & lhsv,
                                const std::valarray<T>& rhs );
template< class T > 
std::valarray<bool> operator> ( const typename std::valarray<T>::value_type & lhsv,
                                const std::valarray<T>& rhs );
template< class T > 
std::valarray<bool> operator>=( const typename std::valarray<T>::value_type & lhsv,
                                const std::valarray<T>& rhs );
    		(2) 
    template< class T > 
std::valarray<bool> operator==( const std::valarray<T>& lhs,
                                const typename std::valarray<T>::value_type & rhsv );
template< class T > 
std::valarray<bool> operator!=( const std::valarray<T>& lhs,
                                const typename std::valarray<T>::value_type & rhsv );
template< class T > 
std::valarray<bool> operator< ( const std::valarray<T>& lhs,
                                const typename std::valarray<T>::value_type & rhsv );
template< class T > 
std::valarray<bool> operator<=( const std::valarray<T>& lhs,
                                const typename std::valarray<T>::value_type & rhsv );
template< class T > 
std::valarray<bool> operator> ( const std::valarray<T>& lhs,
                                const typename std::valarray<T>::value_type & rhsv );
template< class T > 
std::valarray<bool> operator>=( const std::valarray<T>& lhs,
                                const typename std::valarray<T>::value_type & rhsv );
    		(3)

    Vergleicht jeden Wert im numerischen Array mit einem anderen Wert.

    1) Gibt ein numerisches Array von bool zurück, das Elemente enthält, von denen jedes durch Anwendung des angegebenen Vergleichsoperators auf die entsprechenden Werte von lhs und rhs erhalten wird.

    Das Verhalten ist undefiniert, wenn size() != v.size().

    2) Gibt ein numerisches Array von bool zurück, das Elemente enthält, von denen jedes durch Anwendung des angegebenen Vergleichsoperators auf lhsv und den entsprechenden Wert von rhs erhalten wird.
    3) Gibt ein numerisches Array von bool zurück, das Elemente enthält, von denen jedes durch Anwendung des angegebenen Vergleichsoperators auf den entsprechenden Wert von lhs und rhsv erhalten wird.

    Parameter

    lhs, rhs - numerische Arrays zum Vergleichen
    lhsv, rhsv - Werte zum Vergleichen mit jedem Element innerhalb eines numerischen Arrays

    Rückgabewert

    Ein numerisches Array von bool das Vergleichsergebnisse der entsprechenden Elemente enthält.

    Exceptions

    Kann implementierungsdefinierte Ausnahmen auslösen.

    Hinweise

    Jeder der Operatoren kann nur instanziiert werden, wenn die folgenden Anforderungen erfüllt sind:

    • Der angegebene Operator kann auf den Typ T angewendet werden.
    • Der Ergebniswert kann eindeutig in bool konvertiert werden.

    Die Funktion kann mit einem von std::valarray abweichenden Rückgabetyp implementiert werden. In diesem Fall hat der Ersatztyp die folgenden Eigenschaften:

    • Alle const-Mitgliedsfunktionen von std::valarray werden bereitgestellt.
    • std::valarray, std::slice_array, std::gslice_array, std::mask_array und std::indirect_array können aus dem Ersatztyp konstruiert werden.
    • Für jede Funktion, die einen const std::valarray<T>& (außer begin() und end()(seit C++11)) nimmt, sollen identische Funktionen hinzugefügt werden, die die Ersatztypen nehmen;
    • Für jede Funktion, die zwei const std::valarray<T>&-Argumente nimmt, sollen identische Funktionen hinzugefügt werden, die jede Kombination von const std::valarray<T>& und Ersatztypen nehmen.
    • Der Rückgabetyp fügt nicht mehr als zwei Ebenen der Templateschachtelung über dem am tiefsten verschachtelten Argumenttyp hinzu.

    Beispiel

    Diesen Code ausführen 
    #include <iostream>
#include <valarray>
int main()
{
    // alle Negativen in einem valarray auf Null setzen
    std::valarray<int> v = {1, -1, 0, -3, 10, -1, -2};
    std::cout << "Vorher: ";
    for (auto n : v)
        std::cout << n << ' ';
    std::cout << '\n';
    v[v < 0] = 0;
    std::cout << "Nachher: ";
    for (auto n : v)
        std::cout << n << ' ';
    std::cout << '\n';
    // das valarray<bool>-Ergebnis von == in einen einzelnen bool konvertieren
    std::valarray<int> a = {1, 2, 3};
    std::valarray<int> b = {2, 4, 6};
    std::cout << "2*a == b ist " << std::boolalpha
              << (2 * a == b).min() << '\n';
}

    Ausgabe: 

    Vorher: 1 -1 0 -3 10 -1 -2
Nachher: 1 0 0 0 10 0 0
2*a == b ist true

    Fehlerberichte

    Die folgenden verhaltensändernden Fehlerberichte wurden rückwirkend auf zuvor veröffentlichte C++-Standards angewendet.

    DR Angewendet auf Verhalten wie veröffentlicht Korrektes Verhalten
    LWG 3074 C++98 T wird sowohl vom Skalar als auch vom valarray für (2,3) abgeleitet,
    was gemischte Typaufrufe verhindert     		leite T nur vom valarray ab