다차원 배열 템플릿 클래스

    struct exarray
    {
        enum ex_kind {
            DIM_ERROR,
            OUT_OF_RANGE
        };
 
        ex_kind     code_;
        std::string err_;
 
        exarray(ex_kind code) {
            code_ = code;
 
            switch (code) {
                case DIM_ERROR:
                    err_ = "dimension error";
                    break;
                case OUT_OF_RANGE:
                    err_ = "out of range";
                    break;
                default:
                    err_ = "unknown error";
            }
        }
 
        std::string& what(void) {
            return err_;
        }
    };
 
    template <typename T>
    class array
    {
        private:
            bool        is_con_;    // container flag
            array<T>*   con_;       // container vector
            T*          mem_;       // value vector
 
            int         dim_;       // dimension
            int         sz_;        // size
            int         pos_;       // current position
 
        public:
            array() {
                is_con_ = false;
                con_ = NULL;
                mem_ = NULL;
                dim_ = 0;
                sz_  = 0;
                pos_ = 0;
            }
 
            array(int s1) {
                set(s1);
            } 
 
            array(int s1, int s2) {
                set(s1, s2);
            }
 
            ~array() {
                clear();
            }
 
            inline void set(int s1) {
                is_con_ = false;
                con_ = NULL;
                mem_ = new T[s1];
                dim_ = 1;
                sz_  = s1;
                pos_ = 0;
            }
 
            inline void set(int s1, int s2) {
                is_con_ = true;
                con_ = new array<T> [s1];
                mem_ = NULL;
                dim_ = 2;
                sz_  = s1;
                pos_ = 0;
                for (int i = 0; i < s1; i++)
                    con_[i].set(s2);
            }
 
            inline void clear(void) {
                if (is_con_) {
                    for (int i = 0; i < sz_; i++) {
                        con_[i].clear();
                        delete [] con_;
                        is_con_ = false;
                        con_ = NULL;
                        dim_ = 0;
                        sz_  = 0;
                        pos_ = 0;
                    }
                }
                else {
                    delete [] mem_;
                    is_con_ = false;
                    mem_ = NULL;
                    dim_ = 0;
                    sz_  = 0;
                    pos_ = 0;
                }
            }
 
            inline void raise_error(exarray::ex_kind err) {
                exarray e(err);
                std::cerr << e.what() << std::endl;
                throw e;
            }
 
            inline array<T>& operator[] (int i) {
                if (dim_ < 2)
                    raise_error(exarray::DIM_ERROR);
                if (i > sz_)
                    raise_error(exarray::OUT_OF_RANGE);
 
                return con_[i];
            }
 
            inline T& operator() (int i1) {
                if (dim_ > 1)
                    raise_error(exarray::DIM_ERROR);
                if (i1 >= sz_)
                    raise_error(exarray::OUT_OF_RANGE);
 
                return mem_[i1];
            }
 
            inline T& operator() (int i1, int i2) {
                if (i1 >= sz_)
                    raise_error(exarray::OUT_OF_RANGE);
 
                return con_[i1](i2);
            }
 
            inline void reset_pos(void) {
                pos_ = 0;
            }
 
            inline int push(T& e) {
                int over = 0;
 
                if (is_con_) {
                    over = con_[pos_].push(e);
                    if (over) {
                        pos_++;
                    }
                    return 0;
                }
 
                mem_[pos_++] = e;
                if (pos_ == sz_) {
                    pos_ = 0;
                    return 1;
                }
                return 0;
            }
 
            inline int size(void) {
                return sz_;
            }
 
            inline int is_container(void) {
                return is_con_;
            }
    };
 
    // function templates
    template <typename T>
    inline array<T>& operator+= (array<T>& ar, T rhs) {
        ar.push(rhs);
        return ar;
    }
 
    template <typename T>
    inline array<T>& operator, (array<T>& ar, T rhs) {
        ar.push(rhs);
        return ar;
    }
 
    template <typename T, typename CharT, class Traits>
    inline std::basic_ostream<CharT, Traits>&
    operator<< (std::basic_ostream<CharT, Traits>& ostr, array<T>& ar) {
        std::basic_ostringstream<CharT, Traits> os;
        os.flags(ostr.flags());
        os.imbue(ostr.getloc());
        os.precision(ostr.precision());
        if (ar.is_container()) 
            for (int i = 0; i < ar.size(); i++)
                os << ar[i] << std::endl;
        else
            for (int i = 0; i < ar.size(); i++)
                os << ar(i) << ' ';
 
        return ostr << os.str();
    }