---
name: "std::valarray"
section: "3"
platform: "linux"
package: "gcc"
version: "16.2.1+r23+gd564253eb6c8-1"
release: "Arch Linux 2026-11-01"
platforms: ["linux"]
url: "https://new.carta.tech/std::valarray"
---

# std::valarray(3)

Smart array designed to support numeric processing.

## NAME

std::valarray\< \_Tp \> - Smart array designed to support numeric processing.

## SYNOPSIS

\#include \<valarray\>

### Public Types

typedef \_Tp **value\_type**\

### Public Member Functions

**valarray** () noexcept\
 Construct an empty array.  template\<class \_Dom\> **valarray** (const \_Expr\< \_Dom, \_Tp \> &\_\_e)\
 **valarray** (const \_Tp &, size\_t)\
 Construct an array with *n* elements initialized to *t*.  template\<typename \_Tp\> **valarray** (const \_Tp \*\_\_restrict\_\_ \_\_p, size\_t \_\_n)\
 **valarray** (const \_Tp \*\_\_restrict\_\_, size\_t)\
 Construct an array initialized to the first *n* elements of *t*.  **valarray** (const **gslice\_array**\< \_Tp \> &)\
 Construct an array with the same size and values in *ga*.  **valarray** (const **indirect\_array**\< \_Tp \> &)\
 Construct an array with the same size and values in *ia*.  **valarray** (const **mask\_array**\< \_Tp \> &)\
 Construct an array with the same size and values in *ma*.  **valarray** (const **slice\_array**\< \_Tp \> &)\
 Construct an array with the same size and values in *sa*.  **valarray** (const valarray &)\
 Copy constructor.  **valarray** (**initializer\_list**\< \_Tp \>)\
 Construct an array with an initializer\_list of values.  **valarray** (size\_t)\
 Construct an array with *n* elements.  **valarray** (valarray &&) noexcept\
 Move constructor.  \_Expr\< \_ValFunClos\< \_ValArray, \_Tp \>, \_Tp \> **apply** (\_Tp \_\_func(\_Tp)) const\
 Apply a function to the array.  \_Expr\< \_RefFunClos\< \_ValArray, \_Tp \>, \_Tp \> **apply** (\_Tp \_\_func(const \_Tp &)) const\
 Apply a function to the array.  **valarray**\< \_Tp \> **cshift** (int \_\_n) const\
 Return a rotated array.  \_Tp **max** () const\
 Return the maximum element using operator\<().  \_Tp **min** () const\
 Return the minimum element using operator\<().  \_UnaryOp\< \_\_logical\_not \>::\_Rt **operator!** () const\
 Return a new valarray by applying unary ! to each element.  template\<class \_Dom\> **valarray**\< \_Tp \> & **operator%=** (const \_Expr\< \_Dom, \_Tp \> &)\
 **valarray**\< \_Tp \> & **operator%=** (const \_Tp &)\
 Set each element e of array to e % *t*.  **valarray**\< \_Tp \> & **operator%=** (const **valarray**\< \_Tp \> &)\
 Modulo elements of array by corresponding elements of *v*.  template\<class \_Dom\> **valarray**\< \_Tp \> & **operator&=** (const \_Expr\< \_Dom, \_Tp \> &)\
 **valarray**\< \_Tp \> & **operator&=** (const \_Tp &)\
 Set each element e of array to e & *t*.  **valarray**\< \_Tp \> & **operator&=** (const **valarray**\< \_Tp \> &)\
 Logical and corresponding elements of *v* with elements of array.  template\<class \_Dom\> **valarray**\< \_Tp \> & **operator\*=** (const \_Expr\< \_Dom, \_Tp \> &)\
 **valarray**\< \_Tp \> & **operator\*=** (const \_Tp &)\
 Multiply each element of array by *t*.  **valarray**\< \_Tp \> & **operator\*=** (const **valarray**\< \_Tp \> &)\
 Multiply elements of array by corresponding elements of *v*.  \_UnaryOp\< \_\_unary\_plus \>::\_Rt **operator+** () const\
 Return a new valarray by applying unary + to each element.  template\<class \_Dom\> **valarray**\< \_Tp \> & **operator+=** (const \_Expr\< \_Dom, \_Tp \> &)\
 **valarray**\< \_Tp \> & **operator+=** (const \_Tp &)\
 Add *t* to each element of array.  **valarray**\< \_Tp \> & **operator+=** (const **valarray**\< \_Tp \> &)\
 Add corresponding elements of *v* to elements of array.  \_UnaryOp\< \_\_negate \>::\_Rt **operator-** () const\
 Return a new valarray by applying unary - to each element.  template\<class \_Dom\> **valarray**\< \_Tp \> & **operator-=** (const \_Expr\< \_Dom, \_Tp \> &)\
 **valarray**\< \_Tp \> & **operator-=** (const \_Tp &)\
 Subtract *t* to each element of array.  **valarray**\< \_Tp \> & **operator-=** (const **valarray**\< \_Tp \> &)\
 Subtract corresponding elements of *v* from elements of array.  template\<class \_Dom\> **valarray**\< \_Tp \> & **operator/=** (const \_Expr\< \_Dom, \_Tp \> &)\
 **valarray**\< \_Tp \> & **operator/=** (const \_Tp &)\
 Divide each element of array by *t*.  **valarray**\< \_Tp \> & **operator/=** (const **valarray**\< \_Tp \> &)\
 Divide elements of array by corresponding elements of *v*.  template\<class \_Dom\> **valarray**\< \_Tp \> & **operator\<\<=** (const \_Expr\< \_Dom, \_Tp \> &)\
 **valarray**\< \_Tp \> & **operator\<\<=** (const \_Tp &)\
 Left shift each element e of array by *t* bits.  **valarray**\< \_Tp \> & **operator\<\<=** (const **valarray**\< \_Tp \> &)\
 Left shift elements of array by corresponding elements of *v*.  template\<class \_Dom\> **valarray**\< \_Tp \> & **operator=** (const \_Expr\< \_Dom, \_Tp \> &)\
 **valarray**\< \_Tp \> & **operator=** (const \_Tp &\_\_t)\
 Assign elements to a value.  **valarray**\< \_Tp \> & **operator=** (const **gslice\_array**\< \_Tp \> &\_\_ga)\
 Assign elements to an array subset.  **valarray**\< \_Tp \> & **operator=** (const **indirect\_array**\< \_Tp \> &\_\_ia)\
 Assign elements to an array subset.  **valarray**\< \_Tp \> & **operator=** (const **mask\_array**\< \_Tp \> &\_\_ma)\
 Assign elements to an array subset.  **valarray**\< \_Tp \> & **operator=** (const **slice\_array**\< \_Tp \> &\_\_sa)\
 Assign elements to an array subset.  **valarray**\< \_Tp \> & **operator=** (const **valarray**\< \_Tp \> &\_\_v)\
 Assign elements to an array.  **valarray** & **operator=** (**initializer\_list**\< \_Tp \> \_\_l)\
 Assign elements to an initializer\_list.  **valarray**\< \_Tp \> & **operator=** (**valarray**\< \_Tp \> &&\_\_v) noexcept\
 Move assign elements to an array.  template\<class \_Dom\> **valarray**\< \_Tp \> & **operator\>\>=** (const \_Expr\< \_Dom, \_Tp \> &)\
 **valarray**\< \_Tp \> & **operator\>\>=** (const \_Tp &)\
 Right shift each element e of array by *t* bits.  **valarray**\< \_Tp \> & **operator\>\>=** (const **valarray**\< \_Tp \> &)\
 Right shift elements of array by corresponding elements of *v*.  **gslice\_array**\< \_Tp \> **operator\[\]** (const **gslice** &\_\_s)\
 Return a reference to an array subset.  \_Expr\< \_GClos\< \_ValArray, \_Tp \>, \_Tp \> **operator\[\]** (const **gslice** &\_\_s) const\
 Return an array subset.  **mask\_array**\< \_Tp \> **operator\[\]** (const **valarray**\< bool \> &\_\_m)\
 Return a reference to an array subset.  **valarray**\< \_Tp \> **operator\[\]** (const **valarray**\< bool \> &\_\_m) const\
 Return an array subset.  **indirect\_array**\< \_Tp \> **operator\[\]** (const **valarray**\< size\_t \> &\_\_i)\
 Return a reference to an array subset.  \_Expr\< \_IClos\< \_ValArray, \_Tp \>, \_Tp \> **operator\[\]** (const **valarray**\< size\_t \> &\_\_i) const\
 Return an array subset.  \_Tp & **operator\[\]** (size\_t \_\_i) noexcept\
 const \_Tp & **operator\[\]** (size\_t) const noexcept\
 **slice\_array**\< \_Tp \> **operator\[\]** (**slice** \_\_s)\
 Return a reference to an array subset.  \_Expr\< \_SClos\< \_ValArray, \_Tp \>, \_Tp \> **operator\[\]** (**slice** \_\_s) const\
 Return an array subset.  template\<class \_Dom\> **valarray**\< \_Tp \> & **operator^=** (const \_Expr\< \_Dom, \_Tp \> &)\
 **valarray**\< \_Tp \> & **operator^=** (const \_Tp &)\
 Set each element e of array to e ^ *t*.  **valarray**\< \_Tp \> & **operator^=** (const **valarray**\< \_Tp \> &)\
 Logical xor corresponding elements of *v* with elements of array.  template\<class \_Dom\> **valarray**\< \_Tp \> & **operator\|=** (const \_Expr\< \_Dom, \_Tp \> &)\
 **valarray**\< \_Tp \> & **operator\|=** (const \_Tp &)\
 Set each element e of array to e \| *t*.  **valarray**\< \_Tp \> & **operator\|=** (const **valarray**\< \_Tp \> &)\
 Logical or corresponding elements of *v* with elements of array.  \_UnaryOp\< \_\_bitwise\_not \>::\_Rt **operator~** () const\
 Return a new valarray by applying unary ~ to each element.  void **resize** (size\_t \_\_size, \_Tp \_\_c=\_Tp())\
 Resize array.  **valarray**\< \_Tp \> **shift** (int \_\_n) const\
 Return a shifted array.  size\_t **size** () const\
 Return the number of elements in array.  \_Tp **sum** () const\
 Return the sum of all elements in the array.  void **swap** (**valarray**\< \_Tp \> &\_\_v) noexcept\
 Swap.

### Friends

struct **\_Array\< \_Tp \>**\

## Detailed Description

### template\<class \_Tp\>

class std::valarray\< \_Tp \>"Smart array designed to support numeric processing.

A valarray is an array that provides constraints intended to allow for effective optimization of numeric array processing by reducing the aliasing that can result from pointer representations. It represents a one-dimensional array from which different multidimensional subsets can be accessed and modified.

**Template Parameters**

*\_Tp* Type of object in the array.

## Constructor & Destructor Documentation

### template\<class \_Tp\> std::valarray\< \_Tp \>::valarray (const \_Tp \* \_\_restrict\_\_, size\_t )

Construct an array initialized to the first *n* elements of *t*.

References **valarray()**.

## Member Function Documentation

### template\<class \_Tp\> \_UnaryOp\< \_\_logical\_not \>::\_Rt std::valarray\< \_Tp \>::operator! () const

Return a new valarray by applying unary ! to each element.

### template\<class \_Tp\> valarray\< \_Tp \> & std::valarray\< \_Tp \>::operator%= (const \_Tp & )

Set each element e of array to e % *t*.

References **valarray()**.

### template\<class \_Tp\> valarray\< \_Tp \> & std::valarray\< \_Tp \>::operator%= (const valarray\< \_Tp \> & )

Modulo elements of array by corresponding elements of *v*.

References **valarray()**.

### template\<class \_Tp\> valarray\< \_Tp \> & std::valarray\< \_Tp \>::operator&= (const \_Tp & )

Set each element e of array to e & *t*.

References **valarray()**.

### template\<class \_Tp\> valarray\< \_Tp \> & std::valarray\< \_Tp \>::operator&= (const valarray\< \_Tp \> & )

Logical and corresponding elements of *v* with elements of array.

References **valarray()**.

### template\<class \_Tp\> valarray\< \_Tp \> & std::valarray\< \_Tp \>::operator\*= (const \_Tp & )

Multiply each element of array by *t*.

References **valarray()**.

### template\<class \_Tp\> valarray\< \_Tp \> & std::valarray\< \_Tp \>::operator\*= (const valarray\< \_Tp \> & )

Multiply elements of array by corresponding elements of *v*.

References **valarray()**.

### template\<class \_Tp\> \_UnaryOp\< \_\_unary\_plus \>::\_Rt std::valarray\< \_Tp \>::operator+ () const

Return a new valarray by applying unary + to each element.

### template\<class \_Tp\> valarray\< \_Tp \> & std::valarray\< \_Tp \>::operator+= (const \_Tp & )

Add *t* to each element of array.

References **valarray()**.

### template\<class \_Tp\> valarray\< \_Tp \> & std::valarray\< \_Tp \>::operator+= (const valarray\< \_Tp \> & )

Add corresponding elements of *v* to elements of array.

References **valarray()**.

### template\<class \_Tp\> \_UnaryOp\< \_\_negate \>::\_Rt std::valarray\< \_Tp \>::operator- () const

Return a new valarray by applying unary - to each element.

### template\<class \_Tp\> valarray\< \_Tp \> & std::valarray\< \_Tp \>::operator-= (const \_Tp & )

Subtract *t* to each element of array.

References **valarray()**.

### template\<class \_Tp\> valarray\< \_Tp \> & std::valarray\< \_Tp \>::operator-= (const valarray\< \_Tp \> & )

Subtract corresponding elements of *v* from elements of array.

References **valarray()**.

### template\<class \_Tp\> valarray\< \_Tp \> & std::valarray\< \_Tp \>::operator/= (const \_Tp & )

Divide each element of array by *t*.

References **valarray()**.

### template\<class \_Tp\> valarray\< \_Tp \> & std::valarray\< \_Tp \>::operator/= (const valarray\< \_Tp \> & )

Divide elements of array by corresponding elements of *v*.

References **valarray()**.

### template\<class \_Tp\> valarray\< \_Tp \> & std::valarray\< \_Tp \>::operator\<\<= (const \_Tp & )

Left shift each element e of array by *t* bits.

References **valarray()**.

### template\<class \_Tp\> valarray\< \_Tp \> & std::valarray\< \_Tp \>::operator\<\<= (const valarray\< \_Tp \> & )

Left shift elements of array by corresponding elements of *v*.

### template\<class \_Tp\> valarray\< \_Tp \> & std::valarray\< \_Tp \>::operator\>\>= (const \_Tp & )

Right shift each element e of array by *t* bits.

References **valarray()**.

### template\<class \_Tp\> valarray\< \_Tp \> & std::valarray\< \_Tp \>::operator\>\>= (const valarray\< \_Tp \> & )

Right shift elements of array by corresponding elements of *v*.

References **valarray()**.

### template\<class \_Tp\> valarray\< \_Tp \> & std::valarray\< \_Tp \>::operator^= (const \_Tp & )

Set each element e of array to e ^ *t*.

References **valarray()**.

### template\<class \_Tp\> valarray\< \_Tp \> & std::valarray\< \_Tp \>::operator^= (const valarray\< \_Tp \> & )

Logical xor corresponding elements of *v* with elements of array.

References **valarray()**.

### template\<class \_Tp\> valarray\< \_Tp \> & std::valarray\< \_Tp \>::operator\|= (const \_Tp & )

Set each element e of array to e \| *t*.

### template\<class \_Tp\> valarray\< \_Tp \> & std::valarray\< \_Tp \>::operator\|= (const valarray\< \_Tp \> & )

Logical or corresponding elements of *v* with elements of array.

References **valarray()**.

### template\<class \_Tp\> \_UnaryOp\< \_\_bitwise\_not \>::\_Rt std::valarray\< \_Tp \>::operator~ () const

Return a new valarray by applying unary ~ to each element.

## Author

Generated automatically by Doxygen for libstdc++ from the source code.