Namespaces
Variants

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

    Depuis fr.cppreference.net
     
    C++
    Support du compilateur
    Environnement libre et hébergé
    Langage
    Bibliothèque standard
    En-têtes de la bibliothèque standard
    Exigences nommées
    Macros de test de fonctionnalités (C++20)
    Bibliothèque de support du langage
    Bibliothèque de concepts (C++20)
    Bibliothèque de diagnostics
    Bibliothèque de gestion de la mémoire
    Bibliothèque de métaprogrammation (C++11)
    Bibliothèque d'utilitaires généraux
    Bibliothèque de conteneurs
    Bibliothèque d'itérateurs
    Bibliothèque de plages (C++20)
    Bibliothèque d'algorithmes
    Bibliothèque de chaînes
    Bibliothèque de traitement de texte
    Bibliothèque numérique
    Bibliothèque de date et heure
    Bibliothèque d'entrée/sortie
    Bibliothèque du système de fichiers (C++17)
    Bibliothèque de support de la concurrence (C++11)
    Bibliothèque de contrôle d'exécution (C++26)
    Spécifications techniques
    Index des symboles
    Bibliothèques externes
     
    Bibliothèque numérique
    Fonctions mathématiques communes
    Fonctions mathématiques spéciales (C++17)
    Constantes mathématiques (C++20)
    Algorithmes d'algèbre linéaire de base (C++26)
    Types parallèles de données (SIMD) (C++26)
    Environnement à virgule flottante (C++11)
    Nombres complexes
    Tableau numérique (valarray)
    Génération de nombres pseudo-aléatoires
    Manipulation de bits (C++20)
    Arithmétique de saturation (C++26)
    Opérations de factorielle
    (C++17)
    (C++17)
    Interpolations
    (C++20)
    (C++20)
    Opérations numériques génériques
    Arithmétique entière vérifiée de style C
    (C++26)
    (C++26)
    (C++26)

     
    std::valarray
    Fonctions membres
    Fonctions non membres
    Classes d'aide
    Guides de déduction (C++17)
     
    Défini dans l'en-tête <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)

    Compare chaque valeur du tableau numérique avec une autre valeur.

    1) Retourne un tableau numérique de bool contenant des éléments dont chacun est obtenu en appliquant l'opérateur de comparaison indiqué aux valeurs correspondantes de lhs et rhs.

    Le comportement est indéfini si size() != v.size().

    2) Retourne un tableau numérique de bool contenant des éléments dont chacun est obtenu en appliquant l'opérateur de comparaison indiqué à lhsv et à la valeur correspondante de rhs.
    3) Retourne un tableau numérique de bool contenant des éléments dont chacun est obtenu en appliquant l'opérateur de comparaison indiqué à la valeur correspondante de lhs et à rhsv.

    Paramètres

    lhs, rhs - tableaux numériques à comparer
    lhsv, rhsv - valeurs à comparer à chaque élément d'un tableau numérique

    Valeur de retour

    Un tableau numérique de bool contenant les résultats de comparaison des éléments correspondants.

    Exceptions

    Peut lever des exceptions définies par l'implémentation.

    Notes

    Chacun des opérateurs ne peut être instancié que si les exigences suivantes sont remplies :

    • L'opérateur indiqué peut être appliqué au type T.
    • La valeur résultat peut être convertie sans ambiguïté en bool.

    La fonction peut être implémentée avec un type de retour différent de std::valarray. Dans ce cas, le type de remplacement a les propriétés suivantes :

    • Toutes const fonctions membres de std::valarray sont fournies.
    • std::valarray, std::slice_array, std::gslice_array, std::mask_array et std::indirect_array peuvent être construits à partir du type de remplacement.
    • Pour chaque fonction prenant un const std::valarray<T>& sauf begin() et end()(depuis C++11), des fonctions identiques prenant les types de remplacement doivent être ajoutées ;
    • Pour chaque fonction prenant deux const std::valarray<T>& arguments, des fonctions identiques prenant toutes les combinaisons de const std::valarray<T>& et de types de remplacement doivent être ajoutées.
    • Le type de retour n'ajoute pas plus de deux niveaux d'imbrication de template par rapport au type d'argument le plus profondément imbriqué.

    Exemple

    Exécuter ce code 
    #include <iostream>
#include <valarray>
int main()
{
    // mettre à zéro tous les négatifs dans un valarray
    std::valarray<int> v = {1, -1, 0, -3, 10, -1, -2};
    std::cout << "Avant : ";
    for (auto n : v)
        std::cout << n << ' ';
    std::cout << '\n';
    v[v < 0] = 0;
    std::cout << "Après : ";
    for (auto n : v)
        std::cout << n << ' ';
    std::cout << '\n';
    // convertir le résultat valarray<bool> de == en un simple bool
    std::valarray<int> a = {1, 2, 3};
    std::valarray<int> b = {2, 4, 6};
    std::cout << "2*a == b est " << std::boolalpha
              << (2 * a == b).min() << '\n';
}

    Sortie : 

    Before: 1 -1 0 -3 10 -1 -2
After: 1 0 0 0 10 0 0
2*a == b is true

    Rapports de défauts

    Les rapports de défauts modifiant le comportement suivants ont été appliqués rétroactivement aux normes C++ précédemment publiées.

    DR Applied to Behavior as published Correct behavior
    LWG 3074 C++98 T est déduit à la fois du scalaire et du valarray pour (2,3) ,
    empêchant les appels de types mixtes     		déduire uniquement T à partir du valarray