What is the correct approach to passing a std::ranges::view type object to a class?

this question concerns having a std::ranges::view type object as a member variable of a class. I'm trying to better understand them so I may write some poor code along the way here!

Suppose we have a function foo() which interfaces with the some data source and returns a std::tuple of range views:

auto foo(int i)
{
  auto v1 = views::iota(i) | views::transform([](int i){ return i++; });
  auto v2 = views::iota(i) | views::filter([](int i){ return i % 2; });
  auto v3 = views::iota(i) | views::transform([](int i){ return i += 3; });
  return std::make_tuple(v1,v2,v3);
}

and we then need to do some processing which involves the three return views of foo(), with there being some interdependence between them. Therefore, I'd like to store them as members of a class, but i'd like to avoid copying the entirety of the underlying data, so I do something like:

template<ranges::view Vx, ranges::view Vy, ranges::view Vz>
struct Processor
{
public:
    Processor(Vx&& x, Vy&& y, Vz&& z) : m_x{x}, m_y{y}, m_z{z} {}

    auto bar() { /* work using m_x, m_y and m_z */ }

private:
    Vx m_x;
    Vy m_y;
    Vz m_z;
};

in which case i'd have to initialise an instance of Processor using std::move, like so:

auto [x,y,x] = foo(10);
Processor p(std::move(x), std::move(y), std::move(z));

Or alternatively, I take x,y and z by value in the constructor of Processor i.e. Processor(Vx x, Vy y, Vz z) : m_x{x}, m_y{y}, m_z{z} {} and can then construct an instance as:

auto [x,y,x] = foo(10);
Processor p(x, y, z);

So, i'd just like to clarify (a) whether this is a good idea and (b) which approach should i be taking of the two? I suspect that pass-by-value is correct (value-semantics, right?) since we are not copying the underlying data, only the view of each one.

Finally, is there any way to constrain the template parameters of Processor further, for example writing something like ranges::view<int> if I know the underlying type of each range when I pass it to the constructor?

Thank you! godbolt link: https://godbolt.org/z/Gx419949n

Views are generally passed by value since usually it doesn't own the data, it just keeps a pointer to the data (of course there are a few exceptions such as single_view), so Processor(Vx x, Vy y, Vz z) should be preferred.

However, it's important to note that views are only guaranteed to be movable. For example, the standard owning_view is a move-only view, so you should ensure that the value is moved to the member in the member initializer list

template<ranges::view Vx, ranges::view Vy, ranges::view Vz>
struct Processor
{
public:
  Processor(Vx x, Vy y, Vz z) 
    : m_x{std::move(x)}, m_y{std::move(y)}, m_z{std::move(z)} {}
private:
  Vx m_x;
  Vy m_y;
  Vz m_z;
}

> Finally, is there any way to constrain the template parameters of
> Processor further, for example writing something like
> ranges::view<int> if I know the underlying type of each range when I
> pass it to the constructor?

You can use the requires clause for additional constraint checking

template<ranges::view Vx, ranges::view Vy, ranges::view Vz>
  requires std::same_as<std::ranges::range_value_t<Vx>, int> && 
           std::same_as<std::ranges::range_value_t<Vy>, int> && 
           std::same_as<std::ranges::range_value_t<Vz>, int>
struct Processor {
  // ...
};