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

                    }
                    reference operator[](size_type index)
                    {
                            return pdata[index];
                    }
                    const_reference operator ()(size_type index)const
                    {
                            return pdata[index];
                    }
                    reference operator()(size_type index)
                    {
                            return pdata[index];
                    }
            public:
                    array_1d_base(T* pd,size_type d1)
                    {
                            dim_count = 1;
                            pdata = pd;
                            dims[0] = d1;
                    }
            protected:
                    array_1d_base() {dim_count=1;}
            };
            template <typename T>
            class array_2d_base : public array_base<T>
            {
            public:
                    const array_1d_base<T> operator[](size_type index)const
                    {
                            return array_1d_base<T>(pdata+index*dims[1],dims[1])
    ;
                    }
                    array_1d_base<T> operator[](size_type index)
                    {
                            return array_1d_base<T>(pdata+index*dims[1],dims[1])
    ;
                    }
                    ////////////////////////////////////////////////////////////
    //
                    // Basic style access
                    const_reference operator ()(size_type index1, size_type inde
    x2)cconst
                    {
                            return pdata[index1 * dims[1] + index2];
                    }
                    reference operator()(size_type index1, size_type index2)
                    {
                            return pdata[index1 * dims[1] + index2];
                    }
            public:
                    array_2d_base(T *pd,size_type d1,size_type d2)
                    {
                            dim_count = 2;
                            pdata   = pd;
                            dims[0] = d1;
                            dims[1] = d2;
                    }
            protected:
                    array_2d_base() {dim_count = 2;}
            };
            template <typename T>
            class array_3d_base : public array_base<T>
            {
            public:
                    const array_2d_base<T> operator[](size_type index)const
                    {
                            return array_2d_base<T>(
                                                            pdata + index * dims
    [1] * dims[2],
                                                            dims[1],
                                                            dims[2]);
                    }
                    array_2d_base<T> operator[](size_type index)
                    {
                            return array_2d_base<T>(
                                                            pdata + index * dims
    [1] * dims[2],
                                                            dims[1],
                                                            dims[2]
                                                            );
                    }
 

                   ////////////////////////////////////////////////////////////
    //
                    // Basic style access
                    /*
                    const_reference operator ()(
                            size_type index1,
                            size_type index2,
                            size_type index3)const
                    {
                            return pdata[
                                                    index1 * dims[1] *dims[2] +
                                                    index2 * dims[2] +
                                                    index3
                                                    ];
                    }*/
                    reference operator()(
                            size_type index1,