fork download
copy 
  1. #include <iterator>
  2. #include <memory>
  3.  
  4. template<template<typename> class C,
  5.          typename T,
  6.          typename Index = std::size_t,
  7.          typename Difference = long
  8.          >
  9. class indexer : public std::iterator<std::random_access_iterator_tag, T, Difference>
  10. {
  11.     using Indexer = indexer<C, T, Index, Difference>;
  12. public:
  13.     indexer(C<T>& c, Index i, Index end)
  14.         : c_(std::addressof(c)), i_(i), end_(end) {}
  15.  
  16.     T& operator*() const {
  17.         return (*c_)[i_];
  18.     };
  19.  
  20.     T& operator[](Index i) const {
  21.         return (*c_)[i_ + i];
  22.     }
  23.  
  24.     Indexer& operator++() {
  25.         ++i_;
  26.         return *this;
  27.     };
  28.  
  29.     Indexer operator++(int) {
  30.         auto&& old = *this;
  31.         operator++();
  32.         return old;
  33.     }
  34.  
  35.     Indexer& operator--() {
  36.         --i_;
  37.         return *this;
  38.     }
  39.  
  40.     Indexer operator--(int) {
  41.         auto&& old = *this;
  42.         operator--();
  43.         return old;
  44.     }
  45.  
  46.     Indexer& operator+=(Index delta) {
  47.         i_ += delta;
  48.         return *this;
  49.     }
  50.  
  51.     Indexer operator-=(Index delta) {
  52.         i_ -= delta;
  53.         return *this;
  54.     }
  55.  
  56.     Difference operator-(Indexer const& other) const {
  57.         return (Difference)i_ - other.i_;
  58.     }
  59.  
  60.     bool operator==(Indexer const& other) const {
  61.         return i_ == other.i_;
  62.     }
  63.  
  64.     bool operator<(Indexer const& other) const {
  65.         return i_ < other.i_;
  66.     }
  67.  
  68. private:
  69.     C<T>* c_;
  70.     Index i_, end_;
  71. };
  72.  
  73. template<template<typename> class C,
  74.          typename T,
  75.          typename Index = std::size_t,
  76.          typename Difference = long,
  77.          typename Delta,
  78.          typename Indexer = indexer<C, T, Index, Difference>
  79.          >
  80. Indexer operator+(indexer<C, T, Index, Difference> lhs, Delta rhs) {
  81.     return lhs += rhs;
  82. }
  83.  
  84. template<template<typename> class C,
  85.          typename T,
  86.          typename Index = std::size_t,
  87.          typename Difference = long,
  88.          typename Delta,
  89.          typename Indexer = indexer<C, T, Index, Difference>
  90.          >
  91. Indexer operator+(Delta lhs, indexer<C, T, Index, Difference> rhs) {
  92.     return rhs += lhs;
  93. }
  94.  
  95. template<template<typename> class C,
  96.          typename T,
  97.          typename Index = std::size_t,
  98.          typename Difference = long,
  99.          typename Delta,
  100.          typename Indexer = indexer<C, T, Index, Difference>
  101.          >
  102. Indexer operator-(indexer<C, T, Index, Difference> lhs, Delta rhs) {
  103.     return lhs -= rhs;
  104. }
  105.  
  106. template<template<typename> class C,
  107.          typename T,
  108.          typename Index = std::size_t,
  109.          typename Difference = long,
  110.          typename Delta,
  111.          typename Indexer = indexer<C, T, Index, Difference>
  112.          >
  113. Indexer operator-(Delta lhs, indexer<C, T, Index, Difference> rhs) {
  114.     return rhs -= lhs;
  115. }
  116.  
  117. template<template<typename> class C,
  118.          typename T,
  119.          typename Index = std::size_t,
  120.          typename Difference = long
  121.          >
  122. bool operator!=(indexer<C, T, Index, Difference> const& lhs, indexer<C, T, Index, Difference> const& rhs) {
  123.     return !(lhs == rhs);
  124. }
  125.  
  126. template<template<typename> class C,
  127.          typename T,
  128.          typename Index = std::size_t,
  129.          typename Difference = long
  130.          >
  131. bool operator>(indexer<C, T, Index, Difference> const& lhs, indexer<C, T, Index, Difference> const& rhs) {
  132.     return rhs < lhs;
  133. }
  134.  
  135. template<template<typename> class C,
  136.          typename T,
  137.          typename Index = std::size_t,
  138.          typename Difference = long
  139.          >
  140. bool operator<=(indexer<C, T, Index, Difference> const& lhs, indexer<C, T, Index, Difference> const& rhs) {
  141.     return !(lhs > rhs);
  142. }
  143.  
  144. template<template<typename> class C,
  145.          typename T,
  146.          typename Index = std::size_t,
  147.          typename Difference = long
  148.          >
  149. bool operator>=(indexer<C, T, Index, Difference> const& lhs, indexer<C, T, Index, Difference> const& rhs) {
  150.     return !(lhs < rhs);
  151. }
  152.  
  153. #include <algorithm>
  154. #include <iostream>
  155. #include <vector>
  156.  
  157. template<typename T>
  158. class vector_view
  159. {
  160. public:
  161.     vector_view(std::vector<T>& v, std::size_t start, std::size_t n)
  162.         : v_(v), start_(start), n_(n) {}
  163.  
  164.     std::size_t size() { return n_; }
  165.     T& operator[](int i) { return v_[start_ + i]; }
  166.  
  167. private:
  168.     std::vector<T>& v_;
  169.     std::size_t start_, n_;
  170. };
  171.  
  172. template<typename T>
  173. indexer<vector_view, T> begin(vector_view<T>& vv) {
  174.     return indexer<vector_view, T>(vv, 0, vv.size());
  175. }
  176.  
  177. template<typename T>
  178. indexer<vector_view, T> end(vector_view<T>& vv) {
  179.     auto&& size = vv.size();
  180.     return indexer<vector_view, T>(vv, size, size);
  181. }
  182.  
  183. int main() {
  184.     std::vector<int> v = {0, 6, 1, 5, 3, 8};
  185.  
  186.     /* double the three elements starting from the 2nd element (i.e. v[2], v[3], v[4]) */
  187.     for (auto& x : vector_view<int>(v, 2, 3))
  188.         x *= 2;
  189.  
  190.     for (auto x : v)
  191.         std::cout << x << ' ';
  192.     std::cout << std::endl;
  193.  
  194.     vector_view<int> vv(v, 3, 3);
  195.     /* sort the three elements starting from the 3rd element */
  196.     std::sort(begin(vv), end(vv));
  197.  
  198.     for (auto x : v)
  199.         std::cout << x << ' ';
  200.     std::cout << std::endl;
  201.  
  202.     return 0;
  203. }
  204.  
Success #stdin #stdout 0s 3432KB
comments (?)
stdin
copy 
Standard input is empty
stdout
copy 
0 6 2 10 6 8 
0 6 2 6 8 10
https://ideone.com/aYHbYT
language:
C++14 (gcc 8.3)
created:
10 years ago
visibility:
secret

Share or Embed source code

Discover > Sphere Engine API

The brand new service which powers Ideone!

Discover > IDE Widget

Widget for compiling and running the source code in a web browser!