std::slice (selector de sectores de Valarray)

Selector de sectores Valarray: esta clase representa un selector de sectores Valarray. No contiene ni hace referencia a ningún elemento; solo describe una selección de elementos para usar como índice en valarray::operator[] .

std::slice es la clase selectora que identifica un subconjunto de std::valarray. Un objeto de tipo std::slice tiene tres valores: el índice inicial, el paso y el número total de valores en el subconjunto. Los objetos de tipo std::slice se pueden usar como índices con el operador [] de valarray.

class slice;

En términos simples, se utiliza para dividir en función de un índice. Un segmento de valarray se define por un índice de inicio, un tamaño y un paso.
Sintaxis:

slice( std::size_t start, std::size_t size, std::size_t stride );
size_t star : is the index of the first element in the selection
size_t size : is the number of elements in the selection
stride : is the span that separates the elements selected.

• En la sintaxis dada, por defecto el constructor es equivalente a slice(0, 0, 0). Este constructor existe solo para permitir la construcción de arrays de sectores.
• Construye un nuevo corte con los parámetros inicio, tamaño, zancada. Este segmento se referirá al tamaño del número de elementos, cada uno con la posición:

  start + 0*stride
  start + 1*stride
  ....
  ....
  start + (size-1)*stride
  

Ejemplo:

slice(1, 5, 4)
Input :  0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18
Output : 1 5 9 13 17 
Explanation : starting from index 1 then next index 1 + 1 * 4 = 5, next index 1 + 2 * 4 = 9, 
              next index 1 + 3 * 4 = 13, next index 1 + 4 * 4 = 17.

Por lo tanto, un corte con un paso superior a 1 no selecciona elementos contiguos en el valarray. Por ejemplo, slice(3, 4, 5) selecciona los elementos 3, 8, 13 y 18.

// C++ program to test the functioning of std::slice
#include <iostream> // std::cout
#include <cstddef> // std::size_t
#include <valarray> // std::valarray, std::slice
  
int main()
{
    std::valarray<int> sample(12);
    // initialising valarray
    for (int i = 0; i < 13; ++i)
        sample[i] = i;
  
    // using slice from start 1 and size 3 and stride 4
    std::valarray<int> bar = sample[std::slice(2, 3, 4)];
  
    // display slice result
    std::cout << "slice(2, 3, 4):";
    for (std::size_t n = 0; n < bar.size(); n++)
        std::cout << ' ' << bar[n];
    std::cout << '\n';
  
    return 0;
}

Producción:

slice(2, 3, 4): 2 6 10

Aplicación: una aplicación simple de slice es encontrar la traza de una array.

// C++ program to find trace of a matrix by using std::slice
#include <iostream> // std::cout
#include <valarray> // std::valarray, std::slice
  
using namespace std;
  
int main()
{
    // row and column of matrix
    int row = 3, col = 3;
  
    // matrix of size row*col in row major form.
    std::valarray<int> matrix(row * col);
  
    // initialising matrix
    for (int i = 0; i < row * col; ++i)
        matrix[i] = i + 1;
  
    // using slice from start 0 with size as col and stride col+1
    std::valarray<int> diagonal = matrix[std::slice(0, col, col + 1)];
  
    // finding trace using diagonal we got using slice
    int index = 0;
    for (int i = 0; i < row; i++) {
        for (int j = 0; j < col; j++)
            std::cout << matrix[index++] << " "; // same as matrix[i][j]
        std::cout << endl;
    }
  
    int sum = 0; // initialising sum as 0
    // calculating trace of matrix
    for (int i = 0; i < diagonal.size(); i++)
        sum += diagonal[i];
    std::cout << "Trace of matrix is : ";
    std::cout << sum << endl; // sum is trace of matrix
    return 0;
}

Producción:

1 2 3 
4 5 6 
7 8 9 
Trace of matrix is : 15

Este artículo es una contribución de Shubham Rana . Si le gusta GeeksforGeeks y le gustaría contribuir, también puede escribir un artículo usando contribuya.geeksforgeeks.org o envíe su artículo por correo a contribuya@geeksforgeeks.org. Vea su artículo que aparece en la página principal de GeeksforGeeks y ayude a otros Geeks.

Escriba comentarios si encuentra algo incorrecto o si desea compartir más información sobre el tema tratado anteriormente.