language: C++11 (gcc-4.7.2)
date: 220 days 23 hours ago
link:
visibility: public 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61

#include <iostream>
#include <initializer_list>
#include <array>
 
template <class T>
struct EIV_t {
  size_t i;
  T      v;
};
 
class EI_t {
public:
  EI_t(size_t i) : i(i) {}
  template <class T>
  EIV_t<T> operator = (const T& v) const
  {
     return EIV_t<T> { i, v };
  }
private:
  size_t i;
}; 
class E_t {
public:
  EI_t operator [] (size_t i) const { return EI_t(i); }
}; 
 
extern E_t E;
 
template <class T, size_t N>
class CArray : private std::array<T,N> {
  typedef std::array<T,N> Base;
public:
  CArray() : Base() {}
  CArray(std::initializer_list<T> l) : Base(l) {}
  CArray(std::initializer_list<EIV_t<T>> l) : Base() {
     for (auto i = l.begin(); i != l.end(); ++i) {
         (*this)[i->i] = i->v;
     }
  }
 
 
  // well, private inheritance has its cost
  using Base::operator [];
  using Base::begin;
  using Base::end;
  using Base::cbegin;
  using Base::cend;
  using Base::iterator;
  using Base::const_iterator;
  // a lot of missing...
};
 
E_t E;
 
int main() {
   CArray<int, 7> a { E[1] = 13, E[6] = 14 };
   for (auto i = a.begin(); i != a.end(); ++i) {
      std::cout << *i << std::endl;
   } 
}