home | help 
std::slice_array(3)	       C++ Standard Libary	     std::slice_array(3)

NAME
     std::slice_array - std::slice_array

Synopsis
	Defined in header <valarray>
	template< class T > class slice_array;

	std::slice_array is a helper template used by the valarray subscript op-
     erator with
	std::slice argument. It has reference semantics to a subset of the array
     specified
	by the std::slice object.

Member types
	Type	   Definition
	value_type T

Member functions
	constructor   constructs a slice_array
		      (public member function)
	destructor    destroys a slice_array
		      (public member function)
	operator=     assigns contents
		      (public member function)
	operator+=
	operator-=
	operator*=
	operator/=
	operator%=     performs  arithmetic  operation	on the array referred by
     slice.
	operator&=    (public member function)
	operator|=
	operator^=
	operator<<=
	operator>>=

Example
     // Run this code

      #include <iostream>
      #include <valarray>

      class Matrix
      {
	  int dim;
	  std::valarray<int> data;
      public:
	  explicit Matrix(int dim, int init = 0)
	      : dim{dim}, data(init, dim*dim) {}
	  void clear(int value = 0) { data = value; }
	  void identity() { clear(); diagonal() = 1; }
	  int& operator()(int x, int y) { return data[dim * y + x]; }

	  std::slice_array<int> diagonal()
	  {
	      return data[std::slice(0, dim, dim + 1)];
	  }
	  std::slice_array<int> secondary_diagonal()
	  {
	      return data[std::slice(dim - 1, dim, dim - 1)];
	  }
	  std::slice_array<int> row(std::size_t row)
	  {
	      return data[std::slice(dim * row, dim, 1)];
	  }
	  std::slice_array<int> column(std::size_t col)
	  {
	      return data[std::slice(col, dim, dim)];
	  }
	  template<unsigned, unsigned> friend class MatrixStack;
      };

      template<unsigned dim = 3, unsigned max = 8> class MatrixStack
      {
	  std::valarray<int> stack;
	  unsigned count = 0;
      public:
	  MatrixStack() : stack(dim * dim * max) {}
	  void print_all() const
	  {
	      std::valarray<int> row(dim*count);
	      for (unsigned r = 0; r != dim; ++r) // screen row
	      {
		  row = stack[std::gslice(r * dim, {count,  dim},  {dim  *  dim,
     1})];
		  for (unsigned i = 0; i != row.size(); ++i)
		      std::cout << row[i] << ((i + 1) % dim ? " " : " a ");
		  std::cout << '\n';
	      }
	  }
	  void push_back(Matrix const& m)
	  {
	      if (count < max)
	      {
		  stack[std::slice(count * dim * dim, dim * dim, 1)]
		      = m.data[std::slice(0, dim * dim, 1)];
		  ++count;
	      }
	  }
      };

      int main()
      {
	  constexpr int dim = 3;
	  Matrix m{dim};
	  MatrixStack<dim,12> stack;

	  m.identity();
	  stack.push_back(m);

	  m.clear(1);
	  m.secondary_diagonal() = 3;
	  stack.push_back(m);

	  for (int i = 0; i != dim; ++i)
	  {
	      m.clear();
	      m.row(i) = i + 1;
	      stack.push_back(m);
	  }

	  for (int i = 0; i != dim; ++i)
	  {
	      m.clear();
	      m.column(i) = i + 1;
	      stack.push_back(m);
	  }

	  m.clear();
	  m.row(1) = std::valarray<int>{4, 5, 6};
	  stack.push_back(m);

	  m.clear();
	  m.column(1) = std::valarray<int>{7, 8, 9};
	  stack.push_back(m);

	  stack.print_all();
      }

Output:
      1  0 0 a 1 1 3 a 1 1 1 a 0 0 0 a 0 0 0 a 1 0 0 a 0 2 0 a 0 0 3 a 0 0 0 a 0
     7 0 a
      0 1 0 a 1 3 1 a 0 0 0 a 2 2 2 a 0 0 0 a 1 0 0 a 0 2 0 a 0 0 3 a 4 5 6 a  0
     8 0 a
      0  0 1 a 3 1 1 a 0 0 0 a 0 0 0 a 3 3 3 a 1 0 0 a 0 2 0 a 0 0 3 a 0 0 0 a 0
     9 0 a

See also
	gslice_array proxy to a subset of a valarray after applying a gslice
		     (class template)

http://cppreference.com 	   2024.06.10		     std::slice_array(3)
home | help