Namespaces
Variants

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

From cppreference.net
C++
Numerics library
std::valarray
Member functions
Non-member functions
Helper classes
Deduction guides (C++17)
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 > operator [ ] ( 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 > operator [ ] ( const std:: valarray < std:: size_t > & indarr ) const ;
(9)
std:: indirect_array < T > operator [ ] ( const std:: valarray < std:: size_t > & indarr ) ;
(10)

Récupérez des éléments individuels ou des parties du tableau.

Les surcharges const qui renvoient des séquences d'éléments créent un nouvel objet std::valarray . Les surcharges non- const renvoient des classes contenant des références aux éléments du tableau.

1,2)

Si pos < size ( ) est false , le comportement est indéfini.

(jusqu'à C++26)

Si pos < size ( ) est false :

  • Si l'implémentation est durcie , une violation de contrat se produit. De plus, si le gestionnaire de violation de contrat retourne sous la sémantique d'évaluation "observer", le comportement est indéfini.
  • Si l'implémentation n'est pas durcie, le comportement est indéfini.
(depuis C++26)
3-10) Si l'argument ne spécifie pas un sous-ensemble valide de * this , le comportement est indéfini.

Table des matières

Paramètres

pos - position de l'élément à retourner
slicearr - slice des éléments à retourner
gslicearr - gslice des éléments à retourner
boolarr - masque des éléments à retourner
indarr - indices des éléments à retourner

Valeur de retour

1,2) Une référence à l'élément correspondant.
3,5,7,9) Un std::valarray objet contenant des copies des éléments sélectionnés.
4,6,8,10) La structure de données correspondante contenant les références aux éléments sélectionnés.

Exceptions

Peut lever des exceptions définies par l'implémentation.

Notes

Pour des valeurs appropriées de std::valarray a , b et des valeurs appropriées de std::size_t i , j , toutes les expressions suivantes sont toujours évaluées à true :

1) ( a [ i ] = q, a [ i ] ) == q pour un a non constant
2) & a [ i + j ] == & a [ i ] + j
  • Cela signifie que les éléments de std::valarray sont adjacents en mémoire.
3) & a [ i ] ! = & b [ j ] pour tous les objets a et b qui ne sont pas des alias l'un de l'autre
  • Cela signifie qu'il n'y a pas d'alias dans les éléments et cette propriété peut être utilisée pour effectuer certains types d'optimisation.

Les références deviennent invalides lors d'un resize() ou lorsque le tableau est détruit.

Pour les surcharges (3,5,7,9) , la fonction peut être implémentée avec un type de retour différent de std::valarray . Dans ce cas, le type de remplacement possède les propriétés suivantes :

Les accès par tranche/masque/indices indirects ne se chaînent pas : v [ v == n ] [ std:: slice ( 0 , 5 , 2 ) ] = x ; est une erreur car std::mask_array (le type de v [ v == n ] ) ne possède pas operator [ ] .

Exemple

Exécuter ce code 
#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';
}

Sortie : 

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

Rapports de défauts

Les rapports de défauts modifiant le comportement suivants ont été appliqués rétroactivement aux normes C++ précédemment publiées.

DR Applicable à Comportement publié Comportement corrigé
LWG 389 C++98 le type de retour de la surcharge (1) était T corrigé en const T &
LWG 430 C++98 le comportement était ambigu pour les surcharges
(3-10) si un sous-ensemble invalide était spécifié 		le comportement est
indéfini dans ce cas