#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;
   } 
}