Namespaces
Variants

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

    С ru.cppreference.net
     
    C++
    Поддержка компилятора
    Автономные и хостированные
    Язык
    Стандартная библиотека
    Заголовки стандартной библиотеки
    Именованные требования
    Макросы проверки возможностей (C++20)
    Библиотека поддержки языка
    Библиотека концепций (C++20)
    Библиотека диагностики
    Библиотека управления памятью
    Библиотека метапрограммирования (C++11)
    Библиотека общих утилит
    Библиотека контейнеров
    Библиотека итераторов
    Библиотека диапазонов (C++20)
    Библиотека алгоритмов
    Библиотека строк
    Библиотека обработки текста
    Числовая библиотека
    Библиотека даты и времени
    Библиотека ввода/вывода
    Библиотека файловой системы (C++17)
    Библиотека поддержки параллелизма (C++11)
    Библиотека управления выполнением (C++26)
    Технические спецификации
    Указатель символов
    Внешние библиотеки
     
    Числовая библиотека
    Общие математические функции
    Специальные математические функции (C++17)
    Математические константы (C++20)
    Базовые алгоритмы линейной алгебры (C++26)
    Типы для параллельной обработки данных (SIMD) (C++26)
    Среда с плавающей запятой (C++11)
    Комплексные числа
    Числовой массив (valarray)
    Генерация псевдослучайных чисел
    Битовые операции (C++20)
    Арифметика с насыщением (C++26)
    Операции над делителями
    (C++17)
    (C++17)
    Интерполяции
    (C++20)
    (C++20)
    Общие числовые операции
    Арифметика с проверкой целых чисел в стиле C
    (C++26)
    (C++26)
    (C++26)

     
    std::valarray
    Функции-члены
    Функции, не являющиеся членами
    Вспомогательные классы
    Руководства по выводу (C++17)
     
    Определены в заголовке <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)

    Сравнивает каждое значение в числовом массиве с другим значением.

    1) Возвращает числовой массив bool содержащий элементы, каждый из которых получен применением указанного оператора сравнения к соответствующим значениям lhs и rhs.

    Поведение не определено, если size() != v.size().

    2) Возвращает числовой массив bool содержащий элементы, каждый из которых получен применением указанного оператора сравнения к lhsv и соответствующему значению rhs.
    3) Возвращает числовой массив bool содержащий элементы, каждый из которых получен применением указанного оператора сравнения к соответствующему значению lhs и rhsv.

    Параметры

    lhs, rhs - числовые массивы для сравнения
    lhsv, rhsv - значения для сравнения с каждым элементом числового массива

    Возвращаемое значение

    Числовой массив типа bool содержащий результаты сравнения соответствующих элементов.

    Исключения

    Может генерировать исключения, определяемые реализацией.

    Примечания

    Каждый из операторов может быть инстанцирован только при выполнении следующих требований:

    • Указанный оператор может быть применен к типу T.
    • Результирующее значение может быть однозначно преобразовано в bool.

    Функция может быть реализована с типом возврата, отличным от std::valarray. В этом случае заменяющий тип обладает следующими свойствами:

    • Все const функции-члены std::valarray предоставлены.
    • std::valarray, std::slice_array, std::gslice_array, std::mask_array и std::indirect_array могут быть сконструированы из заменяющего типа.
    • Для каждой функции, принимающей const std::valarray<T>& за исключением begin() и end()(начиная с C++11), должны быть добавлены идентичные функции, принимающие заменяющие типы;
    • Для каждой функции, принимающей два аргумента const std::valarray<T>&, должны быть добавлены идентичные функции, принимающие любую комбинацию const std::valarray<T>& и заменяющих типов.
    • Тип возврата не добавляет более двух уровней вложенности шаблонов по сравнению с наиболее глубоко вложенным типом аргумента.

    Пример

    Запустить этот код 
    #include <iostream>
#include <valarray>
int main()
{
    // обнулить все отрицательные значения в valarray
    std::valarray<int> v = {1, -1, 0, -3, 10, -1, -2};
    std::cout << "До: ";
    for (auto n : v)
        std::cout << n << ' ';
    std::cout << '\n';
    v[v < 0] = 0;
    std::cout << "После: ";
    for (auto n : v)
        std::cout << n << ' ';
    std::cout << '\n';
    // преобразовать результат valarray<bool> от == в одиночный bool
    std::valarray<int> a = {1, 2, 3};
    std::valarray<int> b = {2, 4, 6};
    std::cout << "2*a == b это " << std::boolalpha
              << (2 * a == b).min() << '\n';
}

    Вывод: 

    До: 1 -1 0 -3 10 -1 -2
После: 1 0 0 0 10 0 0
2*a == b это true

    Отчеты о дефектах

    Следующие отчеты об изменениях в поведении, являющиеся дефектными, были применены ретроактивно к ранее опубликованным стандартам C++.

    DR Applied to Behavior as published Correct behavior
    LWG 3074 C++98 T выводится как из скаляра, так и из valarray для (2,3) ,
    запрещая вызовы со смешанными типами     		выводить T только из valarray