vector_view.cpp

#include <iostream>
#include <vector>
#include <algorithm>

template <class T>
class vector_view {
    std::vector<T>& base_;
    std::size_t start_;
    std::size_t size_;
public:
    using iterator = typename std::vector<T>::iterator;
    using const_iterator = typename std::vector<T>::const_iterator;

    explicit vector_view(std::vector<T>& base, std::size_t start, std::size_t size)
        : base_(base), start_(start), size_(size) {}

    iterator begin() {
        if (start_ < base_.size()) {
            return base_.begin() + start_;
        }
        return end();
    }

    const_iterator begin() const {
        return cbegin();
    }

    const_iterator cbegin() const {
        if (start_ < base_.size()) {
            return base_.cbegin() + start_;
        }
        return cend();
    }

    iterator end() {
        const std::size_t size = (std::min)(start_ + size_, base_.size());
        return base_.begin() + size;
    }

    const_iterator end() const {
        return cend();
    }

    const_iterator cend() {
        const std::size_t size = (std::min)(start_ + size_, base_.size());
        return base_.cbegin() + size;
    }
};

int main()
{
    std::vector<int> v = {1, 2, 3, 4, 5};

    // slice v[1..3]. result : [2, 3, 4]
    for (int x : vector_view<int>(v, 1, 3)) {
        std::cout << x << ' ';
    }
    std::cout << std::endl;

    // rounded slice v[3..3]. result : [4, 5]
    for (int x : vector_view<int>(v, 3, 3)) {
        std::cout << x << ' ';
    }
    std::cout << std::endl;
}