RepoMain/ZCppMain/ZCArray.H

#ifndef __ZTCARRAY_H__
#define __ZTCARRAY_H__


#include "ZMainHead.H"


namespace ZNsMain
{

    template<   typename Type               ,
                typename TypeArg=const Type&,
                typename TSize  =long
            >
    class ZtCArray  /////////////////////////
    {
    public:
        typedef TSize    TypeSize;
        typedef Type     TypeData;
        typedef ZtCArray ZCArray ;
    public:
        class ZCIterator;
    public:
        typedef       Type*            IterEasy;
        typedef       ZCIterator       iterator;
        typedef const ZCIterator const_iterator;
    public:

        class ZCIterator
        {
        private:                mutable
            Type*    mp_Data  ; mutable
            TSize    ml_ElePos; // *mp_Data <20><> <20>迭<EFBFBD><E8BFAD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD>ϴ<EFBFBD> <20><>ġ
            ZCArray* mp_CArray;
        public:

            ZCIterator()
            {
                mp_Data  =0;
                mp_CArray=0;
                ml_ElePos=0;
            }/*
            ZCIterator()*/

            ZCIterator(ZCArray& AR_CArray, Type& AR_CData, TSize AL_ElePos)
            {
                mp_Data  =&AR_CData ;
                mp_CArray=&AR_CArray;
                ml_ElePos=AL_ElePos ;
            }/*
            ZCIterator(ZCArray& AR_CArray, Type& AR_CData, TSize AL_ElePos)*/

            ZCIterator(ZCArray& AR_CArray)
            {
                mp_Data  = AR_CArray.mp_TypeArr         ;
                mp_CArray=&AR_CArray                    ;
                ml_ElePos=(AR_CArray.size()>0 ? 1 : 0 ) ;
            }/*
            ZCIterator(ZCArray& AR_CArray)*/

            ZCIterator(const ZCArray& AR_CArray)
            {
                mp_Data  = AR_CArray.mp_TypeArr;
                mp_CArray=const_cast<ZCArray*>(&AR_CArray);
                ml_ElePos=(AR_CArray.size()>0 ? 1 : 0 ) ;
            }/*
            ZCIterator(const ZCArray& AR_CArray)*/

            Type& operator*( ){return *mp_Data;}
            Type* operator->(){return  mp_Data;}

            const Type& operator* () const{return *mp_Data;}
            const Type* operator->() const{return  mp_Data;}

            ZCIterator& operator++(   ){++mp_Data; ++ml_ElePos; return *this;}
            ZCIterator  operator++(int){++mp_Data; ++ml_ElePos; return *this;}

            const ZCIterator& operator++(   ) const{++mp_Data; ++ml_ElePos; return *this;}
            const ZCIterator  operator++(int) const{++mp_Data; ++ml_ElePos; return *this;}

            ZCIterator operator+(TSize AL_AddPos) const
            {
                return ZCIterator(*this, mp_Data+AL_AddPos, ml_ElePos+AL_AddPos);
            }/*
            ZCIterator operator+(TSize AL_AddPos) const*/

        public:
        };/*
        class ZCIterator

    public   :*/
    protected:
        enum{ZEAddSize=20};
    protected:

        Type*    mp_TypeArr ;
        TypeSize ml_AllSize ;
        TypeSize ml_UseSize ;
        TypeSize ml_AddSize ;

        /*  TSize ml_AddSize <20><>  <20>߰<EFBFBD> <20>޸𸮸<DEB8> <20><><EFBFBD><EFBFBD>. <20><> <20><><EFBFBD><EFBFBD> <20><><EFBFBD>Ұ<EFBFBD> <20><><EFBFBD>ԵǼ<D4B5>
            <EFBFBD><EFBFBD><EFBFBD>Ҵ<EFBFBD><EFBFBD>ؾ<EFBFBD> <EFBFBD><EFBFBD> <EFBFBD><EFBFBD><EFBFBD><EFBFBD>, ml_AddSize <EFBFBD><EFBFBD> <EFBFBD><EFBFBD>ŭ<EFBFBD><EFBFBD> <EFBFBD≯<EFBFBD> <EFBFBD>Ҵ<EFBFBD><EFBFBD>Ѵ<EFBFBD>.

    protected:*/
    public   :


        ZtCArray()
        {
            mp_TypeArr  =0;
            ml_AllSize  =0;
            ml_UseSize  =0;
            ml_AddSize  =ZEAddSize;
        }/*
        ZtCArray()*/

        ZtCArray(const ZtCArray& rhs)
        {
            mp_TypeArr  =0;
            ml_AllSize  =0;
            ml_UseSize  =0;
            ml_AddSize  =ZEAddSize;

            *this=rhs;
        }/*
        ZtCArray(const ZtCArray& rhs)*/

        ~ZtCArray()
        {
            Delete();
        }/*
        ~ZtCArray()*/

        ZCArray& operator=(const ZCArray& rhs)
        {
            ReAlloc(rhs.ml_UseSize, false);

            ml_UseSize=rhs.ml_UseSize;
            ml_AllSize=rhs.ml_AllSize;

            for(TypeSize i=0; i<ml_UseSize; ++i)
            {
                mp_TypeArr[i]=rhs.mp_TypeArr[i];
            }/*
            for(TypeSize i=0; i<ml_UseSize; ++i)*/

            return *this;
        }/*
        ZCArray& operator=(const ZCArray& rhs)*/

        ZCArray& operator()(TypeArg AR_TypeArg)
        {
            AddTail(AR_TypeArg); return *this;
        }/*
        ZCArray& operator()(TypeArg AR_TypeArg)*/


        void Delete()
        {
            delete [] mp_TypeArr;

            mp_TypeArr  =0;
            ml_AllSize  =0;
            ml_UseSize  =0;
        }/*
        void Delete()*/

        void clear()
        {
            Delete();
        }/*
        void clear()*/


        TypeSize GetAllSize() const{return ml_AllSize;}
        TypeSize GetUseSize() const{return ml_UseSize;}
        TypeSize GetAddSize() const{return ml_AddSize;}

        TypeSize size    () const{return ml_UseSize;}
        TypeSize capacity() const{return ml_AllSize;}


        void SetAddSize(TypeSize AL_NewAddSize)
        {
            if(AL_NewAddSize>=1) ml_AddSize=AL_NewAddSize;
        }/*
        void SetAddSize(TypeSize AL_NewAddSize)*/

        void SetUseSize(TypeSize AL_NewUseSize)
        {
            if(AL_NewUseSize>=0 && AL_NewUseSize<=ml_AllSize)
            {
                ml_UseSize=AL_NewUseSize;
            }/*
            if(AL_NewUseSize>=0 && AL_NewUseSize<=ml_AllSize)*/
        }/*
        void SetUseSize(TypeSize AL_NewUseSize)*/


        void ReAlloc(TypeSize AL_AllocSize, bool AB_DoKeep=true)
        {
            if(AL_AllocSize<1) return ;

            if(AL_AllocSize<ml_AllSize)
            {
                return ;
            }
            if(AL_AllocSize-ml_AllSize<ml_AddSize)
            {
                AL_AllocSize=ml_AllSize+ml_AddSize ;
            }/*
            if(AL_AllocSize-ml_AllSize<ml_AddSize)*/

            if(mp_TypeArr==0)
            {
                mp_TypeArr =new Type[AL_AllocSize];
                ml_AllSize =AL_AllocSize          ;

                return ;
            }/*
            if(mp_TypeArr==0)*/

            if(AB_DoKeep)
            {
                Type* VP_ArrType=new Type[AL_AllocSize] ;

                memcpy(VP_ArrType, mp_TypeArr, ml_AllSize*sizeof(Type));

                delete [] mp_TypeArr;  mp_TypeArr=VP_ArrType;
            }
            else
            {
                delete [] mp_TypeArr;  mp_TypeArr=new Type[AL_AllocSize] ;
            }/*
            else*/

            ml_AllSize=AL_AllocSize;
        }/*
        void ReAlloc(TypeSize AL_AllocSize, bool AB_DoKeep=true)*/


        // cf) std::vecter<type>::assign(size_type _Count, const type&);

        void assign(TypeSize AL_AllocSize, bool AB_DoKeep=true)
        {
            this->ReAlloc(AL_AllocSize, AB_DoKeep);
            this->SetUseSize(AL_AllocSize);
        }/*
        void assign(TypeSize AL_AllocSize, bool AB_DoKeep=true)*/


        Type& operator[](TypeSize AL_Index)
        {
        #ifdef _DEBUG

            if(AL_Index>=ml_UseSize)
            {
                std::fstream fileout("DEBUG.txt",std::ios::out | std::ios::app);
                fileout<<std::endl<<"File : "<<__FILE__<<std::endl<<"Line : "<<__LINE__<<std::endl;
                fileout<<"Error In 'Type& operator[](TypeSize AL_Index)"<<std::endl;
                fileout<<"      AL_Index>=ml_UseSize"<<", "<<AL_Index<<">="<<ml_UseSize<<std::endl;
                fileout.close();

                ::exit(1);
            }/*
            if(AL_Index>=ml_UseSize)*/

        #endif //_DEBUG

            return mp_TypeArr[AL_Index] ;
        }/*
        Type& operator[](TypeSize AL_Index)*/

        const Type& operator[](TypeSize AL_Index) const
        {
        #ifdef _DEBUG

            if(AL_Index>=ml_UseSize)
            {
                std::fstream fileout("DEBUG.txt", std::ios::out | std::ios::app);
                fileout<<std::endl<<"File : "<<__FILE__<<std::endl<<"Line : "<<__LINE__<<std::endl;
                fileout<<"Error In 'const Type& operator[](TypeSize AL_Index) const"<<std::endl;
                fileout<<"      AL_Index>=ml_UseSize"<<std::endl;
                fileout.close();

                ::exit(1);
            }/*
            if(AL_Index>=ml_UseSize)*/

        #endif //_DEBUG

            return mp_TypeArr[AL_Index] ;
        }/*
        const Type& operator[](TypeSize AL_Index) const*/


        Type& GetData(TypeSize AL_Index)
        {
        #ifdef _DEBUG

            if(AL_Index>=ml_UseSize)
            {
                std::fstream fileout("DEBUG.txt",std::ios::out | std::ios::app);
                fileout<<std::endl<<"File : "<<__FILE__<<std::endl<<"Line : "<<__LINE__<<std::endl;
                fileout<<"Error In 'Type& GetData(TypeSize AL_Index)"<<std::endl;
                fileout<<"      AL_Index>=ml_UseSize"<<std::endl;
                fileout.close();

                ::exit(1);
            }/*
            if(AL_Index>=ml_UseSize)*/

        #endif //_DEBUG

            return mp_TypeArr[AL_Index] ;
        }/*
        Type& GetData(TypeSize AL_Index)*/

        const Type& GetData(TypeSize AL_Index) const
        {
        #ifdef _DEBUG

            if(AL_Index>=ml_UseSize)
            {
                std::fstream fileout("DEBUG.txt",std::ios::out | std::ios::app);
                fileout<<std::endl<<"File : "<<__FILE__<<std::endl<<"Line : "<<__LINE__<<std::endl;
                fileout<<"Error In 'const Type& GetData(TypeSize AL_Index) const"<<std::endl;
                fileout<<"      AL_Index>=ml_UseSize"<<std::endl;
                fileout.close();

                ::exit(1);
            }/*
            if(AL_Index>=ml_UseSize)*/

        #endif //_DEBUG

            return mp_TypeArr[AL_Index];
        }/*
        const Type& GetData(TypeSize AL_Index) const*/


        void AddHead(TypeArg AR_TypeArg)
        {
            ReAlloc((ml_UseSize++)+1);

            for(TypeSize i=ml_UseSize-2; i>=0; --i)
            {
                mp_TypeArr[i+1]=mp_TypeArr[i] ;
            }/*
            for(TypeSize i=ml_UseSize-2; i>=0; --i)*/

            mp_TypeArr[0]=AR_TypeArg ;
        }/*
        void AddHead(TypeArg AR_TypeArg)*/

        Type& AddHead()
        {
            // <20>տ<EFBFBD> <20><> <20><><EFBFBD>Ҹ<EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD>ϰ<EFBFBD> <20><> <20><><EFBFBD>Ҹ<EFBFBD> <20><>ȯ<EFBFBD>Ѵ<EFBFBD>.

            ReAlloc((ml_UseSize++)+1);

            for(TypeSize i=ml_UseSize-2; i>=0; --i)
            {
                mp_TypeArr[i+1]=mp_TypeArr[i] ;
            }/*
            for(TypeSize i=ml_UseSize-2; i>=0; --i)*/

            return mp_TypeArr[0] ;
        }/*
        Type& AddHead()*/

        void AddTail(TypeArg AR_TypeArg)
        {
            ReAlloc((ml_UseSize++)+1);  mp_TypeArr[ml_UseSize-1]=AR_TypeArg ;
        }/*
        void AddTail(TypeArg AR_TypeArg)*/

        Type& AddTail()
        {
            // <20><><EFBFBD><EFBFBD> <20><> <20><><EFBFBD>Ҹ<EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD>ϰ<EFBFBD> <20><> <20><><EFBFBD>Ҹ<EFBFBD> <20><>ȯ<EFBFBD>Ѵ<EFBFBD>.

            ReAlloc((ml_UseSize++)+1);  return mp_TypeArr[ml_UseSize-1];
        }/*
        Type& AddTail()*/

        operator Type&()
        {
            return AddTail();
        }/*
        operator Type&()*/


        void push_back(TypeArg AR_TypeArg)
        {
            AddTail(AR_TypeArg);
        }/*
        void push_back(TypeArg AR_TypeArg)*/

        Type& push_back()
        {
            return AddTail();
        }/*
        Type& push_back()*/

        ZCIterator begin()
        {
            return ZCIterator(*this);
        }/*
        ZCIterator begin()*/

        const ZCIterator begin() const
        {
            return ZCIterator(*this);
        }/*
        const ZCIterator begin() const*/


        template<typename TFunctor> void IterElement(TFunctor AO_Functor)
        {
            Type* VP_TypeArr = mp_TypeArr;

            __for0(TypeSize, i, ml_UseSize)
            {
                ZNsMain::CTypeData_T<TFunctor>::
                    GetObjRef(AO_Functor)(*VP_TypeArr);  ++VP_TypeArr;

                /*  <20><> <20>ڵ<EFBFBD><DAB5><EFBFBD> <20><><EFBFBD>ؼ<EFBFBD>, AO_Functor <20><> <20>Լ<EFBFBD><D4BC><EFBFBD> <20><> <20><><EFBFBD><EFBFBD> <20>ƴ϶<C6B4>,
                    operator() <EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ڸ<EFBFBD> <EFBFBD><EFBFBD><EFBFBD><EFBFBD> object <EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <EFBFBD><EFBFBD><EFBFBD><EFBFBD> <EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <EFBFBD><EFBFBD> <EFBFBD>ְ<EFBFBD> <EFBFBD>Ǿ<EFBFBD><EFBFBD><EFBFBD>. */
            }/*
            __for0(TypeSize, i, ml_UseSize)*/
        }/*
        template<typename TFunctor> void IterElement(TFunctor AO_Functor)*/

        template<typename TFunctor, typename TTypeHelp>
            void IterElement(TFunctor AO_Functor, TTypeHelp AO_TypeHelp)
        {
            /*/////////////////////////////////////////////////////////////////////////////
            
            <EFBFBD><EFBFBD>   TTypeHelp <EFBFBD><EFBFBD> class <EFBFBD><EFBFBD> <EFBFBD><EFBFBD><EFBFBD><EFBFBD>, ũ<EFBFBD>Ⱑ Ŀ<EFBFBD><EFBFBD> <EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <EFBFBD>Ѿ<EFBFBD><EFBFBD> <EFBFBD>Ѵٸ<EFBFBD>,
            
                    IterElement<myFunctor, myClass&>(myFunctor_obj, myClass_Obj);

                <EFBFBD><EFBFBD> <EFBFBD><EFBFBD><EFBFBD>·<EFBFBD> ȣ<EFBFBD><EFBFBD><EFBFBD><EFBFBD> <EFBFBD><EFBFBD> <EFBFBD>ƴ϶<EFBFBD>, ZNsMain::ZtCObjectPtr<> <EFBFBD><EFBFBD> <EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>Ͽ<EFBFBD>,

                    myClass myClass_Obj;  ZNsMain::ZtCObjectPtr<myClass> myCObjPtr(myClass_Obj);

                <EFBFBD><EFBFBD>

                    IterElement(myFunctor_obj, ZNsMain::ZtCObjectPtr<myClass>(myClass_Obj));

                <EFBFBD><EFBFBD><EFBFBD>¸<EFBFBD> <EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ϸ<EFBFBD> <EFBFBD><EFBFBD><EFBFBD><EFBFBD> <EFBFBD><EFBFBD> <EFBFBD><EFBFBD><EFBFBD><EFBFBD>. -- 2014-06-16 23:11:00

            /////////////////////////////////////////////////////////////////////////////*/


            Type* VP_TypeArr = mp_TypeArr;

            __for0(TypeSize, i, ml_UseSize)
            {
                ZNsMain::CTypeData_T<TFunctor>::
                    GetObjRef(AO_Functor)(*VP_TypeArr, AO_TypeHelp);  ++VP_TypeArr;
            }/*
            __for0(TypeSize, i, ml_UseSize)*/
        }/*
        template<typename TFunctor, typename TTypeHelp>
            void IterElement(TFunctor AO_Functor, TTypeHelp AO_TypeHelp)*/


        template<typename TFunctor, typename TTypeHelp1, typename TTypeHelp2>
            void IterElement(TFunctor AO_Functor,
                TTypeHelp1 AO_TypeHelp1, TTypeHelp2 AO_TypeHelp2)
        {
            /*/////////////////////////////////////////////////////////////////////////////
            
            <EFBFBD><EFBFBD>   TTypeHelp <EFBFBD><EFBFBD> class <EFBFBD><EFBFBD> <EFBFBD><EFBFBD><EFBFBD><EFBFBD>, ũ<EFBFBD>Ⱑ Ŀ<EFBFBD><EFBFBD> <EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <EFBFBD>Ѿ<EFBFBD><EFBFBD> <EFBFBD>Ѵٸ<EFBFBD>,
            
                    IterElement<myFunctor, myClass&>(myFunctor_obj, myClass_Obj);

                <EFBFBD><EFBFBD> <EFBFBD><EFBFBD><EFBFBD>·<EFBFBD> ȣ<EFBFBD><EFBFBD><EFBFBD><EFBFBD> <EFBFBD><EFBFBD> <EFBFBD>ƴ϶<EFBFBD>, ZNsMain::ZtCObjectPtr<> <EFBFBD><EFBFBD> <EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>Ͽ<EFBFBD>,

                    myClass myClass_Obj;  ZNsMain::ZtCObjectPtr<myClass> myCObjPtr(myClass_Obj);

                <EFBFBD><EFBFBD>

                    IterElement(myFunctor_obj, ZNsMain::ZtCObjectPtr<myClass>(myClass_Obj));

                <EFBFBD><EFBFBD><EFBFBD>¸<EFBFBD> <EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ϸ<EFBFBD> <EFBFBD><EFBFBD><EFBFBD><EFBFBD> <EFBFBD><EFBFBD> <EFBFBD><EFBFBD><EFBFBD><EFBFBD>. -- 2014-06-16 23:11:00

            /////////////////////////////////////////////////////////////////////////////*/


            Type* VP_TypeArr = mp_TypeArr;

            __for0(TypeSize, i, ml_UseSize)
            {
                ZNsMain::CTypeData_T<TFunctor>::GetObjRef(AO_Functor)
                    (*VP_TypeArr, AO_TypeHelp1, AO_TypeHelp2);

                ++VP_TypeArr; ///////////////////////////////////////
            }/*
            __for0(TypeSize, i, ml_UseSize)*/
        }/*
        template<typename TFunctor, typename TTypeHelp1, typename TTypeHelp2>
            void IterElement(TFunctor AO_Functor,
                TTypeHelp1 AO_TypeHelp1, TTypeHelp2 AO_TypeHelp2)*/


        /*///////////////////////////////////////////////////////////////////////////

        <EFBFBD><EFBFBD>  IterElement() <EFBFBD><EFBFBD><EFBFBD><EFBFBD>.

            #include <iostream>
            #include "ZCArray.H"

            using namespace std    ;
            using namespace ZNsMain;

            int main()
            {
                std:: ZtCArray<int> myArray;

                myArray.AddTail(10);
                myArray.AddTail(20);
                myArray.AddTail(30);
                myArray.AddTail(40);

                struct StFunctor
                {
                    static void ShowElement(int ArgiValue){cout<<"# Value="<<ArgiValue<<endl;}
                };

                myArray.IterElement(StFunctor::ShowElement);

                return 0;
            }

        <EFBFBD><EFBFBD>  -- 2014-06-16 23:34:00
        
        ///////////////////////////////////////////////////////////////////////////*/


        /*///////////////////////////////////////////////////////////////////////////

        <EFBFBD><EFBFBD>  <EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <EFBFBD><EFBFBD> <EFBFBD><EFBFBD><EFBFBD>Ҹ<EFBFBD> <EFBFBD><EFBFBD>ȸ<EFBFBD><EFBFBD> <EFBFBD><EFBFBD> <EFBFBD>ִ<EFBFBD> <EFBFBD>ڷ<EFBFBD> <EFBFBD><EFBFBD><EFBFBD><EFBFBD>, <EFBFBD><EFBFBD> <EFBFBD><EFBFBD><EFBFBD><EFBFBD>Ʈ<EFBFBD><EFBFBD> <EFBFBD>迭 Ŭ<EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>

                MoveNextIter(),  MovePrevIter()

            <EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <EFBFBD><EFBFBD><EFBFBD><EFBFBD> <EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <EFBFBD><EFBFBD><EFBFBD>ߴ<EFBFBD>. stl <EFBFBD><EFBFBD> <EFBFBD>ݺ<EFBFBD><EFBFBD>ڴ<EFBFBD> <EFBFBD>ʹ<EFBFBD> <EFBFBD>Ϲ<EFBFBD>ȭ<EFBFBD>ϴٺ<EFBFBD><EFBFBD><EFBFBD>, <EFBFBD><EFBFBD><EFBFBD><EFBFBD> <EFBFBD><EFBFBD><EFBFBD><EFBFBD>
            <EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <EFBFBD>߻<EFBFBD><EFBFBD><EFBFBD> <EFBFBD><EFBFBD> <EFBFBD><EFBFBD><EFBFBD><EFBFBD>.

            -- 2011-06-07 20:25:00

            GetDataInIter() <EFBFBD><EFBFBD> <EFBFBD>߰<EFBFBD><EFBFBD>ߴ<EFBFBD>.

            -- 2011-06-12 20:42:00

        ///////////////////////////////////////////////////////////////////////////*/

        Type*      GetHeadIterEasy  (){return              mp_TypeArr              ;}
        Type*      GetTailIterEasy  (){return              mp_TypeArr+ml_UseSize-1 ;}
        IterEasyID GetHeadIterEasyID(){return (IterEasyID) mp_TypeArr              ;}
        IterEasyID GetTailIterEasyID(){return (IterEasyID)(mp_TypeArr+ml_UseSize-1);}

        const Type*      GetHeadIterEasy  () const{return              mp_TypeArr              ;}
        const Type*      GetTailIterEasy  () const{return              mp_TypeArr+ml_UseSize-1 ;}
        const IterEasyID GetHeadIterEasyID() const{return (IterEasyID) mp_TypeArr              ;}
        const IterEasyID GetTailIterEasyID() const{return (IterEasyID)(mp_TypeArr+ml_UseSize-1);}

        IterEasyID ItHead() {return GetHeadIterEasyID();}
        IterEasyID ItTail() {return GetTailIterEasyID();}

        const IterEasyID ItHead() const{return GetHeadIterEasyID();}
        const IterEasyID ItTail() const{return GetTailIterEasyID();}


        void MoveNextIter(Type*& APR_CType) const
        {
            ++APR_CType;
        }/*
        void MoveNextIter(Type*& APR_CType) const*/

        void MoveNextIter(iterator& ARR_CIterator) const
        {
            ++ARR_CIterator;
        }/*
        void MoveNextIter(iterator& ARR_CIterator) const*/

        void MoveNextIter(IterEasyID& AI_IterEasyID) const
        {
            MoveNextIter((Type*&)AI_IterEasyID);
        }/*
        void MoveNextIter(IterEasyID& AI_IterEasyID) const*/

        void MoveNextIter(const Type*& APR_CType) const
        {
            ++APR_CType;
        }/*
        void MoveNextIter(const Type*& APR_CType) const*/

        void MoveNextIter(const iterator& ARR_CIterator) const
        {
            ++ARR_CIterator;
        }/*
        void MoveNextIter(const iterator& ARR_CIterator) const*/

        void MoveNextIter(const IterEasyID& AI_IterEasyID) const
        {
            MoveNextIter((const Type*&)AI_IterEasyID);
        }/*
        void MoveNextIter(const IterEasyID& AI_IterEasyID) const*/


        void MovePrevIter(Type*& APR_CType) const
        {
            --APR_CType;
        }/*
        void MovePrevIter(Type*& APR_CType) const*/

        void MovePrevIter(iterator& ARR_CIterator) const
        {
            --ARR_CIterator;
        }/*
        void MovePrevIter(iterator& ARR_CIterator) const*/

        void MovePrevIter(IterEasyID& AI_IterEasyID) const
        {
            MovePrevIter((Type*&)AI_IterEasyID);
        }/*
        void MovePrevIter(IterEasyID& AI_IterEasyID) const*/

        void MovePrevIter(const Type*& APR_CType) const
        {
            --APR_CType;
        }/*
        void MovePrevIter(const Type*& APR_CType)*/

        void MovePrevIter(const iterator& ARR_CIterator) const
        {
            --ARR_CIterator;
        }/*
        void MovePrevIter(const iterator& ARR_CIterator) const*/

        void MovePrevIter(const IterEasyID& AI_IterEasyID) const
        {
            MovePrevIter((const Type*&)AI_IterEasyID);
        }/*
        void MovePrevIter(const IterEasyID& AI_IterEasyID) const*/


        Type& GetDataInIter(Type* AP_CType)
        {
            return *AP_CType;
        }/*
        Type& GetDataInIter(Type* AP_CType)*/

        Type& GetDataInIter(iterator& ARR_CIterator)
        {
            return *ARR_CIterator;
        }/*
        Type& GetDataInIter(iterator& ARR_CIterator)*/

        Type& GetDataInIter(IterEasyID AI_IterEasyID)
        {
            return *(Type*)AI_IterEasyID;
        }/*
        Type& GetDataInIter(IterEasyID AI_IterEasyID)*/

        const Type& GetDataInIter(const Type* AP_CType) const
        {
            return *AP_CType;
        }/*
        const Type& GetDataInIter(const Type* AP_CType) const*/

        const Type& GetDataInIter(const iterator& ARR_CIterator) const
        {
            return *ARR_CIterator;
        }/*
        const Type& GetDataInIter(const iterator& ARR_CIterator) const*/

        const Type& GetDataInIter(const IterEasyID AI_IterEasyID) const
        {
            return *(const Type*)AI_IterEasyID;
        }/*
        const Type& GetDataInIter(const IterEasyID AI_IterEasyID) const*/


        Type& GetDataInIter(Type* AP_Type, TypeSize AI_FarNum)
        {
            return *(AP_Type + AI_FarNum);
        }/*
        Type& GetDataInIter(Type* AP_Type, TypeSize AI_FarNum)*/

        Type& GetDataInIter(iterator& ARR_CIterator, TypeSize AI_FarNum)
        {
            return *(ARR_CIterator+AI_FarNum);
        }/*
        Type& GetDataInIter(iterator& ARR_CIterator, TypeSize AI_FarNum)*/

        Type& GetDataInIter(IterEasyID ARRI_IterEasyID, TypeSize AI_FarNum)
        {
            return GetDataInIter((Type*)ARRI_IterEasyID, AI_FarNum);
        }/*
        Type& GetDataInIter(IterEasyID ARRI_IterEasyID, TypeSize AI_FarNum)*/


        const Type& GetDataInIter(const Type* AP_Type, TypeSize AI_FarNum) const
        {
            return *(AP_Type + AI_FarNum);
        }/*
        const Type& GetDataInIter(const Type* AP_Type, TypeSize AI_FarNum) const*/

        const Type& GetDataInIter(iterator& ARR_CIterator, TypeSize AI_FarNum) const
        {
            return *(ARR_CIterator+AI_FarNum);
        }/*
        const Type& GetDataInIter(iterator& ARR_CIterator, TypeSize AI_FarNum) const*/

        const Type& GetDataInIter(const IterEasyID ARRI_IterEasyID, TypeSize AI_FarNum) const
        {
            return GetDataInIter((const Type*)ARRI_IterEasyID, AI_FarNum);
        }/*
        const Type& GetDataInIter(const IterEasyID ARRI_IterEasyID, TypeSize AI_FarNum) const*/


        // <20>Ʒ<EFBFBD> ItD() <20>Լ<EFBFBD><D4BC><EFBFBD> GetDataInIter() <20><> ª<><C2AA> <20><><EFBFBD><EFBFBD> <20><><EFBFBD>̴<EFBFBD>.

        Type& ItD(Type*      AP_Type                            ){return GetDataInIter(AP_Type                   );}
        Type& ItD(iterator&  ARR_CIterator                      ){return GetDataInIter(ARR_CIterator             );}
        Type& ItD(IterEasyID ARRI_IterEasyID                    ){return GetDataInIter(ARRI_IterEasyID           );}
        Type& ItD(Type*      AP_Type        , TypeSize AI_FarNum){return GetDataInIter(AP_Type       , AI_FarNum );}
        Type& ItD(iterator&  ARR_CIterator  , TypeSize AI_FarNum){return GetDataInIter(ARR_CIterator  , AI_FarNum);}
        Type& ItD(IterEasyID ARRI_IterEasyID, TypeSize AI_FarNum){return GetDataInIter(ARRI_IterEasyID, AI_FarNum);}

        const Type& ItD(const Type*      AP_Type                            ) const{return GetDataInIter(AP_Type                   );}
        const Type& ItD(const iterator&  ARR_CIterator                      ) const{return GetDataInIter(ARR_CIterator             );}
        const Type& ItD(const IterEasyID ARRI_IterEasyID                    ) const{return GetDataInIter(ARRI_IterEasyID           );}
        const Type& ItD(const Type*      AP_Type        , TypeSize AI_FarNum) const{return GetDataInIter(AP_Type                   );}
        const Type& ItD(const iterator&  ARR_CIterator  , TypeSize AI_FarNum) const{return GetDataInIter(ARR_CIterator  , AI_FarNum);}
        const Type& ItD(const IterEasyID ARRI_IterEasyID, TypeSize AI_FarNum) const{return GetDataInIter(ARRI_IterEasyID, AI_FarNum);}

    public:
    };/*
    template<   typename Type               ,
                typename TypeArg=const Type&,
                typename TSize  =long
            >
    class ZtCArray ////////////////////////*/


    //////////////////////////////////////////////

    ////////////// end class ZCArray //////////////

    //////////////////////////////////////////////



    /*////////////////////////////////////////////////////////////////////

    <EFBFBD><EFBFBD>  class ZtCArrayFixed<> <EFBFBD><EFBFBD> <EFBFBD>迭 <EFBFBD>޸𸮸<EFBFBD> <EFBFBD><EFBFBD>ü <EFBFBD>Ҵ<EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <EFBFBD>ʰ<EFBFBD>,
        <EFBFBD>̹<EFBFBD> <EFBFBD>ܺο<EFBFBD><EFBFBD><EFBFBD> new <EFBFBD><EFBFBD> <EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>Ǿ<EFBFBD> <EFBFBD>ִ<EFBFBD> <EFBFBD>迭<EFBFBD><EFBFBD> <EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>Ѵ<EFBFBD>.
        <EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> ZtCArrayFixed<> <EFBFBD><EFBFBD><EFBFBD>ο<EFBFBD><EFBFBD><EFBFBD> <EFBFBD><EFBFBD><EFBFBD>Ƿ<EFBFBD> <EFBFBD>迭 ũ<EFBFBD>⸦ <EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <EFBFBD><EFBFBD> <EFBFBD><EFBFBD><EFBFBD><EFBFBD>.

        -- 2011-08-05 20:40:00

    ////////////////////////////////////////////////////////////////////*/

    template<   typename Type,
                typename TSize=long
            >
    class ZtCArrayFixed ///////////
    {
    public:
        typedef Type TypeData;
    public:
        typedef const Type* const_iterator;
        typedef       Type*       iterator;
    private:
        Type* mp_TypeArr;
        TSize ml_UseSize;
    public:

        ZtCArrayFixed()
        {
            Init(0, 0);
        }
        ZtCArrayFixed(TypeData* AP_DataArr, TSize AL_ArrSize)
        {
            Init(AP_DataArr, AL_ArrSize);
        }
        void Init(TypeData* AP_DataArr, TSize AL_ArrSize)
        {
            mp_TypeArr=AP_DataArr;
            ml_UseSize=AL_ArrSize;
        }/*
        void Init(TypeData* AP_DataArr,TSize AL_ArrSize)*/

        TSize size() const{return ml_UseSize;}


        Type& operator[](TSize AL_Index)
        {
        #ifdef _DEBUG

            if(AL_Index>=ml_UseSize)
            {
                std::fstream fileout("DEBUG.txt",std::ios::out | std::ios::app);
                fileout<<std::endl<<"File : "<<__FILE__<<std::endl<<"Line : "<<__LINE__<<std::endl;
                fileout<<"Error In 'Type& operator[](TSize AL_Index)"<<std::endl;
                fileout<<"      AL_Index>=ml_UseSize"<<", "<<AL_Index<<">="<<ml_UseSize<<std::endl;
                fileout.close();

                ::exit(1);
            }/*
            if(AL_Index>=ml_UseSize)*/

        #endif //_DEBUG

            return mp_TypeArr[AL_Index] ;
        }/*
        Type& operator[](TSize AL_Index)*/

        const Type& operator[](TSize AL_Index) const
        {
        #ifdef _DEBUG

            if(AL_Index>=ml_UseSize)
            {
                std::fstream fileout("DEBUG.txt",std::ios::out | std::ios::app);
                fileout<<std::endl<<"File : "<<__FILE__<<std::endl<<"Line : "<<__LINE__<<std::endl;
                fileout<<"Error In 'const Type& operator[](TSize AL_Index) const"<<std::endl;
                fileout<<"      AL_Index>=ml_UseSize"<<std::endl;
                fileout.close();

                ::exit(1);
            }/*
            if(AL_Index>=ml_UseSize)*/

        #endif //_DEBUG

            return mp_TypeArr[AL_Index] ;
        }/*
        const Type& operator[](TSize AL_Index) const*/


        Type& GetData(TSize AL_Index)
        {
        #ifdef _DEBUG

            if(AL_Index>=ml_UseSize)
            {
                std::fstream fileout("DEBUG.txt",std::ios::out | std::ios::app);
                fileout<<std::endl<<"File : "<<__FILE__<<std::endl<<"Line : "<<__LINE__<<std::endl;
                fileout<<"Error In 'Type& GetData(TSize AL_Index)"<<std::endl;
                fileout<<"      AL_Index>=ml_UseSize"<<std::endl;
                fileout.close();

                ::exit(1);
            }/*
            if(AL_Index>=ml_UseSize)*/

        #endif //_DEBUG

            return mp_TypeArr[AL_Index] ;
        }/*
        Type& GetData(TSize AL_Index)*/

        const Type& GetData(TSize AL_Index) const
        {
        #ifdef _DEBUG

            if(AL_Index>=ml_UseSize)
            {
                std::fstream fileout("DEBUG.txt",std::ios::out | std::ios::app);
                fileout<<std::endl<<"File : "<<__FILE__<<std::endl<<"Line : "<<__LINE__<<std::endl;
                fileout<<"Error In 'const Type& GetData(TSize AL_Index) const"<<std::endl;
                fileout<<"      AL_Index>=ml_UseSize"<<std::endl;
                fileout.close();

                ::exit(1);
            }/*
            if(AL_Index>=ml_UseSize)*/

        #endif //_DEBUG

            return mp_TypeArr[AL_Index];
        }/*
        const Type& GetData(TSize AL_Index) const*/


              Type* begin()       { return mp_TypeArr; }
        const Type* begin() const { return mp_TypeArr; }


        void MoveNextIter(Type*& ARR_CIterator) const
        {
            ++ARR_CIterator;
        }/*
        void MoveNextIter(Type*& ARR_CIterator) const*/

        void MovePrevIter(iterator& ARR_CIterator)
        {
            --ARR_CIterator;
        }/*
        void MovePrevIter(iterator& ARR_CIterator)*/


        void MoveNextIter(const_iterator& ARR_CIterator) const
        {
            ++ARR_CIterator;
        }/*
        void MoveNextIter(const_iterator& ARR_CIterator) const*/

        void MovePrevIter(const_iterator& ARR_CIterator) const
        {
            --ARR_CIterator;
        }/*
        void MovePrevIter(const_iterator& ARR_CIterator) const*/

        /*////////////////////////////////////////////////////

        <EFBFBD><EFBFBD> <EFBFBD>ڵ带 <EFBFBD>Ʒ<EFBFBD><EFBFBD><EFBFBD> <EFBFBD>ϸ<EFBFBD> <EFBFBD>ȵȴ<EFBFBD>.

        void MoveNextIter(const iterator& ARR_CIterator) const
        {
            ++ARR_CIterator;
        }
      //void MoveNextIter(const iterator& ARR_CIterator) const

        void MovePrevIter(const iterator& ARR_CIterator) const
        {
            --ARR_CIterator;
        }
      //void MovePrevIter(const iterator& ARR_CIterator) const

        const iterator <EFBFBD><EFBFBD> Type const * const <EFBFBD><EFBFBD><EFBFBD><EFBFBD> Type const * <EFBFBD><EFBFBD> <EFBFBD>ƴϴ<EFBFBD>.

        -- 2011-08-05 23:49:00

        ////////////////////////////////////////////////////*/


        Type& GetDataInIter(iterator& ARR_CIterator)
        {
            return *ARR_CIterator;
        }/*
        Type& GetDataInIter(iterator& ARR_CIterator)*/

        const Type& GetDataInIter(const_iterator& ARR_CIterator) const
        {
            return *ARR_CIterator;
        }/*
        const Type& GetDataInIter(const_iterator& ARR_CIterator) const*/


    public:
    };/*
    template<   typename Type,
                typename TSize=long
            >
    class ZtCArrayFixed /////////*/

}/*
namespace ZNsMain*/


#endif //__ZTCARRAY_H__