Namespaces
Variants

std:: slice

From cppreference.net
C++
Numerics library
std::valarray
Member functions
Non-member functions
Helper classes
Deduction guides (C++17)
Défini dans l'en-tête <valarray>
class slice ;

std::slice est la classe de sélecteur qui identifie un sous-ensemble de std::valarray similaire à une tranche BLAS . Un objet de type std::slice contient trois valeurs : l'indice de départ, le pas (stride) et le nombre total d'éléments dans le sous-ensemble. Les objets de type std::slice peuvent être utilisés comme indices avec l'opérateur operator [ ] du valarray.

Table des matières

Fonctions membres

(constructor)
construit un slice
(fonction membre publique)
start size stride
retourne les paramètres du slice
(fonction membre publique)

std::slice:: slice

slice ( )
(1)
slice ( std:: size_t start, std:: size_t size, std:: size_t stride ) ;
(2)
slice ( const slice & other ) ;
(3)

Construit une nouvelle tranche.

1) Constructeur par défaut. Équivalent à slice ( 0 , 0 , 0 ) . Ce constructeur existe uniquement pour permettre la construction de tableaux de tranches.
2) Construit une nouvelle tranche avec les paramètres start , size , stride . Cette tranche fera référence à size éléments, chacun ayant la position :
start + 0 * stride
start + 1 * stride
...
start + (size - 1) * stride
3) Construit une copie de other .

Paramètres

start - la position du premier élément
size - le nombre d'éléments dans la tranche
stride - le nombre de positions entre les éléments successifs dans la tranche
other - une autre tranche à copier

std::slice:: start, size, stride

std:: size_t start ( ) const ;
(1)
std:: size_t size ( ) const ;
(2)
std:: size_t stride ( ) const ;
(3)

Retourne les paramètres passés à la tranche lors de la construction - respectivement start, size et stride.

Paramètres

(aucun)

Valeur de retour

Les paramètres de la tranche -- respectivement start, size et stride.

Complexité

Constante.

Fonctions non membres

operator== (std::slice)
(C++20)
vérifie si deux tranches sont égales
(fonction)

operator== (std::slice)

friend bool operator == ( const slice & lhs, const slice & rhs ) ;
(depuis C++20)

Vérifie si les paramètres de lhs et rhs - start, size et stride sont respectivement égaux.

Cette fonction n'est pas visible pour la recherche non qualifiée ordinaire ou la recherche qualifiée , et ne peut être trouvée que par la recherche dépendante des arguments lorsque std::slice est une classe associée des arguments.

L'opérateur != est synthétisé à partir de operator== .

Paramètres

lhs, rhs - slices à comparer

Valeur de retour

lhs. start ( ) == rhs. start ( ) && lhs. size ( ) == rhs. size ( ) && lhs. stride ( ) == rhs. stride ( )

Exemple

Classe Matrix basique utilisant valarray avec une fonction de calcul de trace .

Exécuter ce code 
#include <iostream>
#include <valarray>
class Matrix
{
    std::valarray<int> data;
    int dim;
public:
    Matrix(int r, int c) : data(r*c), dim(c) {}
    int& operator()(int r, int c) { return data[r * dim + c]; }
    int trace() const { return data[std::slice(0, dim, dim + 1)].sum(); }
};
int main()
{
    Matrix m(3, 3);
    int n = 0;
    for (int r = 0; r < 3; ++r)
       for (int c = 0; c < 3; ++c)
           m(r, c) = ++n;
    std::cout << "Trace of the matrix (1,2,3) (4,5,6) (7,8,9) is " << m.trace() << '\n';
}

Sortie : 

Trace of the matrix (1,2,3) (4,5,6) (7,8,9) is 15

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 Appliqué à Comportement tel que publié Comportement correct
LWG 543 C++98 il n'était pas clair si un slice construit par défaut est utilisable il est utilisable (comme un sous-ensemble vide)

Voir aussi

obtenir/définir un élément, une tranche ou un masque de valarray
(fonction membre publique)
tranche généralisée d'un valarray : index de départ, ensemble de longueurs, ensemble de pas
(classe)
proxy vers un sous-ensemble d'un valarray après application d'une tranche
(modèle de classe)
(C++23)
une vue de tableau multidimensionnelle non propriétaire
(modèle de classe)