fork download
copy 
  1. #include <iostream>
  2. #include <vector>
  3. #include <memory>
  4.  
  5. template <class ApparentElemType> class readonly_vector_view_base;
  6.  
  7. template <class ApparentElemType>
  8. class readonly_vector_view
  9. {
  10.   public:
  11.     readonly_vector_view(const readonly_vector_view& other) : pimpl(other.pimpl) {}
  12.     readonly_vector_view(std::shared_ptr<readonly_vector_view_base<ApparentElemType>> pimpl_) : pimpl(pimpl_) {}
  13.  
  14.     typedef typename readonly_vector_view_base<ApparentElemType>::iter iter_base;
  15.     class iter
  16.     {
  17.       public:
  18.         iter(std::unique_ptr<iter_base> it_) : it(it_->clone()) {}
  19.         iter(const iter& other) : it(other.it->clone()) {}
  20.         iter& operator=(iter& other) { it = other.it->clone(); return *this; }
  21.  
  22.         ApparentElemType operator*() const { return **it; }
  23.         iter& operator++() { ++*it; return *this; }
  24.         iter& operator--() { --*it; return *this; }
  25.         iter operator++(int) { iter n(*this); ++*it; return n; }
  26.         iter operator--(int) { iter n(*this); --*it; return n; }
  27.         bool operator== (const iter& other) const { return *it == *other.it; }
  28.         bool operator!= (const iter& other) const { return *it != *other.it; }
  29.       private:
  30.         std::unique_ptr<iter_base> it;
  31.     };
  32.  
  33.     iter begin() { return iter(pimpl->begin()); }
  34.     iter end() { return iter(pimpl->end()); }
  35.   private:
  36.     std::shared_ptr<readonly_vector_view_base<ApparentElemType>> pimpl;
  37. };
  38.  
  39. template <class ApparentElemType>
  40. struct readonly_vector_view_base
  41. {
  42.     struct iter
  43.     {
  44.         virtual std::unique_ptr<iter> clone() const = 0;
  45.  
  46.         virtual ApparentElemType operator*() const = 0;
  47.         virtual iter& operator++() = 0;
  48.         virtual iter& operator--() = 0;
  49.         virtual bool operator== (const iter& other) const = 0;
  50.         virtual bool operator!= (const iter& other) const = 0;
  51.         virtual ~iter(){}
  52.     };
  53.  
  54.     virtual std::unique_ptr<iter> begin() = 0;
  55.     virtual std::unique_ptr<iter> end() = 0;
  56.  
  57.     virtual ~readonly_vector_view_base() {}
  58. };
  59.  
  60. template <class ElemType, class ApparentElemType>
  61. struct readonly_vector_view_impl : readonly_vector_view_base<ApparentElemType>
  62. {
  63.     typedef typename readonly_vector_view_base<ApparentElemType>::iter iter_base;
  64.  
  65.     readonly_vector_view_impl(std::shared_ptr<std::vector<ElemType>> vec_) : vec(vec_) {}
  66.  
  67.     struct iter : iter_base
  68.     {
  69.         std::unique_ptr<iter_base> clone() const { std::unique_ptr<iter_base> x(new iter(it)); return x; }
  70.  
  71.         iter(typename std::vector<ElemType>::iterator it_) : it(it_) {}
  72.  
  73.         ApparentElemType operator*() const { return *it; }
  74.         iter& operator++() { ++it; return *this; }
  75.         iter& operator--() { ++it; return *this; }
  76.  
  77.         bool operator== (const iter_base& other) const {
  78.             const iter* real_other = dynamic_cast<const iter*>(&other);
  79.             return (real_other && it == real_other->it);
  80.         }
  81.         bool operator!= (const iter_base& other) const { return ! (*this == other); }
  82.  
  83.         typename std::vector<ElemType>::iterator it;
  84.     };
  85.  
  86.     std::unique_ptr<iter_base> begin() {
  87.         iter* x (new iter(vec->begin()));
  88.         std::unique_ptr<iter_base> y(x);
  89.         return y;
  90.     }
  91.     std::unique_ptr<iter_base> end() {
  92.         iter* x (new iter(vec->end()));;
  93.         std::unique_ptr<iter_base> y(x);
  94.         return y;
  95.     }
  96.  
  97.     std::shared_ptr<std::vector<ElemType>> vec;
  98. };
  99.  
  100.  
  101. struct A
  102. {
  103.     A(int x_) : x(x_) {};
  104.  
  105.     readonly_vector_view<A*> test() { return test_A(); }
  106.     virtual readonly_vector_view<A*> test_A() = 0;
  107.  
  108.     int x;
  109. };
  110.  
  111. struct B : A
  112. {
  113.     B (int y_, int x_) : y(y_), A(x_) {}
  114.     B() : A(0), bvec(std::make_shared<std::vector<B*>>())
  115.     {
  116.         bvec->push_back (new B(2,3));
  117.         bvec->push_back (new B(4,5));
  118.         bvec->push_back (new B(6,7));
  119.     }
  120.     std::shared_ptr<std::vector<B*>> bvec;
  121.  
  122.     readonly_vector_view<B*> test() { return test_B(); }
  123.  
  124.     virtual readonly_vector_view<A*> test_A() {
  125.         return readonly_vector_view<A*>(std::make_shared<readonly_vector_view_impl<B*, A*>>(bvec));
  126.     }
  127.     virtual readonly_vector_view<B*> test_B() {
  128.         return readonly_vector_view<B*>(std::make_shared<readonly_vector_view_impl<B*, B*>>(bvec));
  129.     }
  130.  
  131.     int y;
  132. };
  133.  
  134. int main ()
  135. {
  136.     B b;
  137.     A& a (b);
  138.  
  139.     readonly_vector_view<A*>va = a.test();
  140.     readonly_vector_view<B*>vb = b.test();
  141.  
  142.     for (readonly_vector_view<A*>::iter pa = va.begin(); pa != va.end(); ++pa)
  143.     {
  144.         std::cout << (*pa)->x << " ";
  145.     }
  146.     std::cout << std::endl;
  147.     for (readonly_vector_view<B*>::iter pb = vb.begin(); pb != vb.end(); ++pb)
  148.     {
  149.         std::cout << (*pb)->x << ":" << (*pb)->y << " ";
  150.     }
  151.     std::cout << std::endl;
  152. }
  153.  
Success #stdin #stdout 0s 3484KB
comments (?)
stdin
copy 
Standard input is empty
stdout
copy 
3 5 7 
3:2 5:4 7:6
https://ideone.com/yD1eWK
language:
C++14 (gcc 8.3)
created:
9 years ago
visibility:
public

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!