cfc::array 一个多维数组类(2)

            public:
                    array(){}
            };
    }
    #endif  file://_ARRAY_H_
    ////////////////////////////////////////////////////////////
    // array_base.h
    #ifndef _ARRAY_BASE_H_
    #define _ARRAY_BASE_H_
    #include <cstddef>
    #include <iterator>
    #include <algorithm>
    #include <stdexcept>
    namespace cfc
    {
            template <typename T>
            class array_base
            {
            public:
            typedef T              value_type;
            typedef T*             iterator;
            typedef const T*       const_iterator;
            typedef T&             reference;
            typedef const T&       const_reference;
            typedef /*std*/::size_t    size_type;
            typedef /*std*/::ptrdiff_t difference_type;
    #ifdef _MSC_VER
            typedef std::reverse_iterator<iterator,T> reverse_iterator;
            typedef std::reverse_iterator<const_iterator,T> const_reverse_iterat

    or;
  

  #else
            typedef std::reverse_iterator<iterator> reverse_iterator;
            typedef std::reverse_iterator<const_iterator> const_reverse_iterator

    ;
    #endif
            public:
            iterator begin() { return pdata; }
            const_iterator begin() const { return pdata; }
            iterator end() { return pdata + size(); }
            const_iterator end() const { return pdata + size(); }
            reverse_iterator rbegin() { return reverse_iterator(end()); }
            const_reverse_iterator rbegin() const {
                return const_reverse_iterator(end());
            }
            reverse_iterator rend() { return reverse_iterator(begin()); }
            const_reverse_iterator rend() const {
                return const_reverse_iterator(begin());
            }
            // at() with range check
            reference at(size_type i) { rangecheck(i); return pdata[i]; }
            const_reference at(size_type i) const { rangecheck(i); return elems[

    i]; }
            // front() and back()
            reference front() { return pdata[0]; }
            const_reference front() const { return pdata[0]; }
            reference back() { return pdata[size()-1]; }
            const_reference back() const { return pdata[size()-1]; }
            // size is constant
            bool empty() { return pdata != 0; }
            size_type max_size() { return size(); }
            // swap (note: linear complexity)
            file://void swap (array<T,N>& y) {
            //    std::swap_ranges(begin(),end(),y.begin());
            file://}
            // direct access to data
            const T* data() const { return pdata; }
                    size_type size() const
                    {
                            int sum=1;
                            for(int i=0;i<dim_count;i++)
                                    sum*=dims[i];
                            return sum;
                    }
            void assign (const T& value)
            {
                std::fill_n(begin(),size(),value);
            }
            void swap (array_base<T>& y)
                    {
                            if(size() != y.size())throw std::length_error("array
    ");
                std::swap_ranges(begin(),end(),y.begin());
            }
                    template <typename T2>
                    array_base<T>& operator= (const array_base<T2>& rhs)
                    {
                            std::copy(rhs.begin(),rhs.end(), begin());
                            return *this;
                    }
                    size_t get_dims(size_t index){return dims[i];}
                    void rangecheck (size_type i)
                    {
                            if (i >= size()) { throw std::range_error("array");
    }
                    }
            protected:
                    array_base(){}
            protected:
                    T * pdata;
                    int dim_count;
                    int dims[3];
                    array_base(int d):dim_count(d){}
            };
            // comparisons
            template<class T1,class T2>
            bool operator== (const array_base<T1>& x, const array_base<T2>& y) {

                    return std::equal(x.begin(), x.end(), y.begin());
            }
            template<class T>
            bool operator< (const array_base<T>& x, const array_base<T>& y) {
                    return std::lexicographical_compare(x.begin(),x.end(),y.begi
    n(),,y.end());
            }
            template<class T1,class T2>
            bool operator!= (const array_base<T1>& x, const array_base<T2>& y) {

                    return !(x==y);
            }
            template<class T1, class T2>
            bool operator> (const array_base<T1>& x, const array_base<T2>& y) {
                    return y<x;
            }
            template<class T1, class T2>
            bool operator<= (const array_base<T1>& x, const array_base<T2>& y) {

                    return !(y<x);
            }
            template<class T1, class T2>
            bool operator>= (const array_base<T1>& x, const array_base<T2>& y) {

                    return !(x<y);
            }
            // global swap()
            template<class T1, class T2>
            inline void swap (array_base<T1>& x, array_base<T2>& y) {
                    x.swap(y);
            }
            template <typename T>
            class array_1d_base:public array_base<T>
            {
            public:
                    const_reference operator [](size_type index)const
                    {
                            return pdata[index];