Namespaces
Variants

operator+,-,*,/,%,&,|,^,<<,>>,&&,|| (std::valarray)

С ru.cppreference.net
 
 
 
 
Определено в заголовке <valarray>
template< class T >
std::valarray<T> operator+ ( const std::valarray<T>& lhs, const std::valarray<T>& rhs );
template< class T >
std::valarray<T> operator- ( const std::valarray<T>& lhs, const std::valarray<T>& rhs );
template< class T >
std::valarray<T> operator* ( const std::valarray<T>& lhs, const std::valarray<T>& rhs );
template< class T >
std::valarray<T> operator/ ( const std::valarray<T>& lhs, const std::valarray<T>& rhs );
template< class T >
std::valarray<T> operator% ( const std::valarray<T>& lhs, const std::valarray<T>& rhs );
template< class T >
std::valarray<T> operator& ( const std::valarray<T>& lhs, const std::valarray<T>& rhs );
template< class T >
std::valarray<T> operator| ( const std::valarray<T>& lhs, const std::valarray<T>& rhs );
template< class T >
std::valarray<T> operator^ ( const std::valarray<T>& lhs, const std::valarray<T>& rhs );
template< class T >
std::valarray<T> operator<<( const std::valarray<T>& lhs, const std::valarray<T>& rhs );
template< class T >
std::valarray<T> 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<T> operator+ ( const typename std::valarray<T>::value_type & val,
                             const std::valarray<T>& rhs );
template< class T >
std::valarray<T> operator- ( const typename std::valarray<T>::value_type & val,
                             const std::valarray<T>& rhs );
template< class T >
std::valarray<T> operator* ( const typename std::valarray<T>::value_type & val,
                             const std::valarray<T>& rhs );
template< class T >
std::valarray<T> operator/ ( const typename std::valarray<T>::value_type & val,
                             const std::valarray<T>& rhs );
template< class T >
std::valarray<T> operator% ( const typename std::valarray<T>::value_type & val,
                             const std::valarray<T>& rhs );
template< class T >
std::valarray<T> operator& ( const typename std::valarray<T>::value_type & val,
                             const std::valarray<T>& rhs );
template< class T >
std::valarray<T> operator| ( const typename std::valarray<T>::value_type & val,
                             const std::valarray<T>& rhs );
template< class T >
std::valarray<T> operator^ ( const typename std::valarray<T>::value_type & val,
                             const std::valarray<T>& rhs );
template< class T >
std::valarray<T> operator<<( const typename std::valarray<T>::value_type & val,
                             const std::valarray<T>& rhs );
template< class T >
std::valarray<T> operator>>( const typename std::valarray<T>::value_type & val,
                             const std::valarray<T>& rhs );
template< class T >
std::valarray<bool> operator&&( const typename std::valarray<T>::value_type & val,
                                const std::valarray<T>& rhs );
template< class T >
std::valarray<bool> operator||( const typename std::valarray<T>::value_type & val,
                                const std::valarray<T>& rhs );
(2)
template< class T >
std::valarray<T> operator+ ( const std::valarray<T>& lhs,
                             const typename std::valarray<T>::value_type & val );
template< class T >
std::valarray<T> operator- ( const std::valarray<T>& lhs,
                             const typename std::valarray<T>::value_type & val );
template< class T >
std::valarray<T> operator* ( const std::valarray<T>& lhs,
                             const typename std::valarray<T>::value_type & val );
template< class T >
std::valarray<T> operator/ ( const std::valarray<T>& lhs,
                             const typename std::valarray<T>::value_type & val );
template< class T >
std::valarray<T> operator% ( const std::valarray<T>& lhs,
                             const typename std::valarray<T>::value_type & val );
template< class T >
std::valarray<T> operator& ( const std::valarray<T>& lhs,
                             const typename std::valarray<T>::value_type & val );
template< class T >
std::valarray<T> operator| ( const std::valarray<T>& lhs,
                             const typename std::valarray<T>::value_type & val );
template< class T >
std::valarray<T> operator^ ( const std::valarray<T>& lhs,
                             const typename std::valarray<T>::value_type & val );
template< class T >
std::valarray<T> operator<<( const std::valarray<T>& lhs,
                             const typename std::valarray<T>::value_type & val );
template< class T >
std::valarray<T> operator>>( const std::valarray<T>& lhs,
                             const typename std::valarray<T>::value_type & val );
template< class T >
std::valarray<bool> operator&&( const std::valarray<T>& lhs,
                                const typename std::valarray<T>::value_type & val );
template< class T >
std::valarray<bool> operator||( const std::valarray<T>& lhs,
                                const typename std::valarray<T>::value_type & val );
(3)

Применяет бинарные операторы к каждому элементу двух valarray или к valarray и значению.

1) Операторы работают с valarray одинакового размера и возвращают valarray того же размера, содержащий результаты применения операции ко всем элементам обоих аргументов.
2,3) Применяет оператор между каждым элементом valarray и скаляром.

Параметры

rhs - числовой массив
lhs - числовой массив
val - значение типа T

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

Valarray того же размера, что и параметр.

Примечание

Поведение не определено, когда два аргумента являются valarrays разных размеров.

Функция может быть реализована с возвращаемым типом, отличным от 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 <cstddef>
#include <iostream>
#include <valarray>
int main()
{
    std::valarray<double> a(1, 8);
    std::valarray<double> b{1, 2, 3, 4, 5, 6, 7, 8};
    std::valarray<double> c = -b;
    // литералы также должны быть типа T до LWG3074 (в данном случае double)
    std::valarray<double> d = std::sqrt(b * b - 4.0 * a * c);
    std::valarray<double> x1 = 2.0 * c / (-b + d);
    std::valarray<double> x2 = 2.0 * c / (-b - d);
    std::cout << "quadratic equation:  root 1:    root 2:   b: c:\n";
    for (std::size_t i = 0; i < a.size(); ++i)
        std::cout << a[i] << "\u00B7x\u00B2 + " << b[i] << "\u00B7x + "
                  << c[i] << " = 0  " << std::fixed << x1[i]
                  << "  " << x2[i] << std::defaultfloat
                  << "  " << -x1[i] - x2[i]
                  << "  " << x1[i] * x2[i] << '\n';
}

Вывод:

quadratic equation:  root 1:    root 2:   b: c:
1·x² + 1·x + -1 = 0  -1.618034  0.618034  1  -1
1·x² + 2·x + -2 = 0  -2.732051  0.732051  2  -2
1·x² + 3·x + -3 = 0  -3.791288  0.791288  3  -3
1·x² + 4·x + -4 = 0  -4.828427  0.828427  4  -4
1·x² + 5·x + -5 = 0  -5.854102  0.854102  5  -5
1·x² + 6·x + -6 = 0  -6.872983  0.872983  6  -6
1·x² + 7·x + -7 = 0  -7.887482  0.887482  7  -7
1·x² + 8·x + -8 = 0  -8.898979  0.898979  8  -8

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

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

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

Смотрите также

применяет унарный арифметический оператор к каждому элементу valarray
(public member function)
применяет оператор составного присваивания к каждому элементу valarray
(public member function)