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 );

Récupérer des éléments individuels ou des portions 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.

Paramètres

Valeur de retour

Exceptions

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

Notes

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

Les références deviennent invalides lors de 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 a les propriétés suivantes :

• Toutes les fonctions membres const de std::valarray sont fournies.
• std::valarray, std::slice_array, std::gslice_array, std::mask_array et std::indirect_array peuvent être construits à partir du type de remplacement.
• Pour chaque fonction prenant un const std::valarray<T>& sauf begin() et end()(depuis C++11), des fonctions identiques prenant les types de remplacement doivent être ajoutées ;
• Pour chaque fonction prenant deux arguments const std::valarray<T>&, des fonctions identiques prenant toutes les combinaisons de const std::valarray<T>& et de types de remplacement doivent être ajoutées.
• Le type de retour n'ajoute pas plus de deux niveaux d'imbrication de template par rapport au type d'argument le plus profondément imbriqué.

Les accès par tranche/masque/index indirect ne s'enchaînent pas : v[v == n][std::slice(0, 5, 2)] = x; est une erreur car std::mask_array (le type de v[v == n]) n'a pas operator[].

Exemple

#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

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.