std::valarray<T>::operator[]

const T&               operator[]( std::size_t pos ) const;

T&                     operator[]( std::size_t pos );

std::valarray<T>       operator[]( std::slice slicearr ) const;

std::slice_array<T>    operator[]( std::slice slicearr );

std::valarray<T>       operator[]( const std::gslice& gslicearr ) const;

std::gslice_array<T>   operator[]( const std::gslice& gslicearr );

std::valarray<T>       operator[]( const std::valarray<bool>& boolarr ) const;

std::mask_array<T>     operator[]( const std::valarray<bool>& boolarr );

std::valarray<T>       operator[]( const std::valarray<std::size_t>& indarr ) const;

std::indirect_array<T> operator[]( const std::valarray<std::size_t>& indarr );

Recupera elementos individuales o porciones del arreglo.

Las const sobrecargas que devuelven secuencias de elementos crean un nuevo objeto std::valarray. Las sobrecargas no const devuelven clases que contienen referencias a los elementos del arreglo.

Parámetros

Valor de retorno

Excepciones

Puede lanzar excepciones definidas por la implementación.

Notas

Para valores apropiados std::valarray a, b y valores apropiados std::size_t i, j, todas las siguientes expresiones siempre se evalúan como true:

Las referencias se invalidan al resize() o cuando se destruye el arreglo.

Para las sobrecargas (3,5,7,9), la función puede implementarse con un tipo de retorno diferente de std::valarray. En este caso, el tipo de reemplazo tiene las siguientes propiedades:

• Todas las funciones miembro de conststd::valarray se proporcionan.std::valarray
• , std::slice_array, std::gslice_array, std::mask_array y std::indirect_array pueden construirse a partir del tipo de reemplazo.Para cada función que toma un
• excepto const std::valarray<T>& begin() y end()(desde C++11), se agregarán funciones idénticas que tomen los tipos de reemplazo;Para cada función que toma dos argumentos
• , se agregarán funciones idénticas que tomen cada combinación de const std::valarray<T>& y tipos de reemplazo.const std::valarray<T>&
• El tipo de retorno no agrega más de dos niveles de anidamiento de plantilla sobre el tipo de argumento más profundamente anidado.

Los accesos de índice por segmento/máscara/indirecto no se encadenan: v[v == n][std::slice(0, 5, 2)] = x; es un error porque std::mask_array (el tipo de v[v == n]) no tiene operator[].

Ejemplo

#include <cstddef>
#include <iomanip>
#include <iostream>
#include <valarray>
int main() 
{
    std::valarray<int> data = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
    std::cout << "Initial valarray:   ";
    for (int n : data)
        std::cout << std::setw(3) << n;
    std::cout << '\n';
    data[data > 5] = -1; // valarray<bool> overload of operator[]
    // the type of data > 5 is std::valarray<bool>
    // the type of data[data > 5] is std::mask_array<int>
    std::cout << "After v[v > 5] = -1:";
    for (std::size_t n = 0; n < data.size(); ++n) 
        std::cout << std::setw(3) << data[n]; // regular operator[]
    std::cout << '\n';
}

Initial valarray:     0  1  2  3  4  5  6  7  8  9
After v[v > 5] = -1:  0  1  2  3  4  5 -1 -1 -1 -1

Informes de defectos

Los siguientes informes de defectos que modifican el comportamiento se aplicaron retroactivamente a los estándares de C++ publicados anteriormente.