Namespaces
Variants

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

From cppreference.net
const T & operator [ ] ( std:: size_t pos ) const ;
(1)
T & operator [ ] ( std:: size_t pos ) ;
(2)
std:: valarray < T > operator [ ] ( std:: slice slicearr ) const ;
(3)
std:: slice_array < T > operator [ ] ( std:: slice slicearr ) ;
(4)
std:: valarray < T > operador [ ] ( const std:: gslice & gslicearr ) const ;
(5)
std:: gslice_array < T > operator [ ] ( const std:: gslice & gslicearr ) ;
(6)
std:: valarray < T > operator [ ] ( const std:: valarray < bool > & boolarr ) const ;
(7)
std:: mask_array < T > operator [ ] ( const std:: valarray < bool > & boolarr ) ;
(8)
std:: valarray < T > operador [ ] ( const std:: valarray < std:: size_t > & indarr ) const ;
(9)
std:: indirect_array < T > operator [ ] ( const std:: valarray < std:: size_t > & indarr ) ;
(10)

Recuperar elementos individuales o porciones del array.

Las sobrecargas const 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.

1,2)

Si pos < size ( ) es false , el comportamiento es indefinido.

(hasta C++26)

Si pos < size ( ) es false :

  • Si la implementación está hardened , ocurre una contract violation . Además, si el manejador de violación de contrato retorna bajo semántica de evaluación "observe", el comportamiento es indefinido.
  • Si la implementación no está hardened, el comportamiento es indefinido.
(desde C++26)
3-10) Si el argumento no especifica un subconjunto válido de * this , el comportamiento es indefinido.

Contenidos

Parámetros

pos - posición del elemento a devolver
slicearr - slice de los elementos a devolver
gslicearr - gslice de los elementos a devolver
boolarr - máscara de los elementos a devolver
indarr - índices de los elementos a devolver

Valor de retorno

1,2) Una referencia al elemento correspondiente.
3,5,7,9) Un objeto std::valarray que contiene copias de los elementos seleccionados.
4,6,8,10) La estructura de datos correspondiente que contiene referencias a los elementos seleccionados.

Excepciones

Puede lanzar excepciones definidas por la implementación.

Notas

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

1) ( a [ i ] = q, a [ i ] ) == q para a no constante
2) & a [ i + j ] == & a [ i ] + j
  • Esto significa que los elementos de std::valarray son adyacentes en memoria.
3) & a [ i ] ! = & b [ j ] para cada objeto a y b que no sean alias uno del otro
  • Esto significa que no hay alias en los elementos y esta propiedad puede utilizarse para realizar ciertos tipos de optimización.

Las referencias se vuelven inválidas al resize() o cuando el array es destruido.

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

Los accesos mediante segmentación/máscara/índices indirectos 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';
}

Salida:

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.

DR Aplicado a Comportamiento publicado Comportamiento correcto
LWG 389 C++98 el tipo de retorno de la sobrecarga (1) era T corregido a const T &
LWG 430 C++98 el comportamiento no estaba claro para las sobrecargas
(3-10) si se especifica un subconjunto inválido
el comportamiento es
indefinido en este caso