#ifndef __ZCPPMAIIN__ZTCARRAY_H__
#define __ZCPPMAIIN__ZTCARRAY_H__


#include "ZCppMain/ZMainHead.H"


namespace ZNsMain
{

    template<   typename TType               ,
                typename TTypArg=const TType&,
                typename TSize  =long
            >
    class ZtCArray  //////////////////////////
    {
    public:
        typedef TType    Type    ;
        typedef TType    TypeData;
        typedef TTypArg  TypeArg ;
        typedef TSize    TypeSize;
        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 가 배열에서 차지하는 위치
            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 는  추가 메모리를 지정. 한 개의 원소가 삽입되서
            재할당해야 할 경우, ml_AddSize 개 만큼을 미리 할당한다.

    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)
        {
            if(this==&rhs)  return *this  ;

            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()
        {
            // 앞에 빈 원소를 삽입하고 그 원소를 반환한다.

            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()
        {
            // 끝에 빈 원소를 삽입하고 그 원소를 반환한다.

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

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


        void push_front(TypeArg AR_TypeArg){AddHead(AR_TypeArg);}
        void push_back (TypeArg AR_TypeArg){AddTail(AR_TypeArg);}

        Type& push_front(){return AddHead();}
        Type& push_back (){return AddTail();}

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


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

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

                ++VP_TypeArr; //////////////////

                /*  ZtCTypeData 으로 인해서, AO_Functor 이 함수일 때뿐이 아니라,
                    operator() 연산자를 가진 object 포인터일 때도 사용할 수 있게 되었다. */
            }/*
            __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)
        {
            /*/////////////////////////////////////////////////////////////////////////////
            
            ■   TTypeHelp 가 class 일 경우, 크기가 커서 참조로 넘어가야 한다면,
            
                    IterElement<myFunctor, myClass&>(myFunctor_obj, myClass_Obj);

                의 형태로 호출할 게 아니라, ZNsMain::ZtCObjectPtr<> 을 사용하여,

                    myClass myClass_Obj;

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

                나

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

                형태를 사용하면 좋을 것 같다. -- 2014-06-16 23:11:00


                ZCCheckRef::PassData() 으로 인해, 인수를 ZtCRef 클래스를 이용해 인수를 참조
                로 넘길 수 있게 되었다. -- 2021-03-10 16:56

                이제는 ZtCRef 과 ZCCheckRef 클래스 템플릿을 사용하면 된다. -- 2021-03-11 11:00

                이제는 ZftMCR() 과 ZftMCP() 을 사용하면 된다. -- 2025-08-07 17:55

            ■  예제1 -- 2025-08-07 17:35
            
                #include <iostream>

                #include "ZCppMain/ZtCArray.H"


                using namespace std    ;
                using namespace ZNsMain;

                int main()
                {
                    ZtCArray<int> myArray;

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

                    class CHelpObj
                    {
                    public:

                        CHelpObj()
                        {
                        }

                        CHelpObj(const CHelpObj& rhs)
                        {
                            cout<<"* CHelpObj(const CHelpObj& rhs)"<<endl;
                        }

                    public:
                    };  CHelpObj VO_CHelpObj; cout<<"VO_CHelpObj Ptr : "<<&VO_CHelpObj<<endl;

                    struct StFunctor
                    {
                        static void ShowElement(int ArgiValue){cout<<"#1 Value="<<ArgiValue<<endl;}
                    };
                    struct StFunctor2
                    {
                        static void ShowElement(int ArgiValue, CHelpObj)
                            {cout<<"#2 Value="<<ArgiValue<<", CHelpObj Addr=None"<<" With CHelpObj"<<endl;}
                    };
                    struct StFunctor3
                    {
                        static void ShowElement(int ArgiValue, CHelpObj& AR_CHelpObj)
                            {cout<<"#3 Value="<<ArgiValue<<", HelpObj Ptr="<<&AR_CHelpObj<<" With CHelpObj Ref"<<endl;}
                    };
                    struct StFunctor4
                    {
                        static void ShowElement(int ArgiValue, CHelpObj& AR_CHelpObj)
                            {cout<<"#4 Value="<<ArgiValue<<", HelpObj Ptr="<<&AR_CHelpObj<<" With CHelpObj in Ptr"<<endl;}
                    };
                    struct StFunctor5
                    {
                        static void ShowElement(int ArgiValue, CHelpObj& AR_CHelpObj, CHelpObj& AR_CHelpObj2)
                            {cout<<"#5 Value="<<ArgiValue<<", HelpObj Ptr="<<&AR_CHelpObj<<" With CHelpObj Ref 2"<<endl;}
                    };
                    struct StFunctor6
                    {
                        static void ShowElement(int ArgiValue, CHelpObj& AR_CHelpObj, CHelpObj AO_CHelpObj2)
                            {cout<<"#6 Value="<<ArgiValue<<", HelpObj Ptr="<<&AR_CHelpObj<<" With CHelpObj Half Ref"<<endl;}
                    };

                    myArray.IterElement(StFunctor ::ShowElement);
                    myArray.IterElement(StFunctor2::ShowElement, VO_CHelpObj );
                    myArray.IterElement(StFunctor3::ShowElement, ZftMCR(VO_CHelpObj) );
                    myArray.IterElement(StFunctor4::ShowElement, ZftMCP(VO_CHelpObj) );
                    myArray.IterElement(StFunctor5::ShowElement, ZftMCP(VO_CHelpObj), ZftMCP(VO_CHelpObj) );
                    myArray.IterElement(StFunctor6::ShowElement, ZftMCP(VO_CHelpObj),        VO_CHelpObj  );

                    return 0;
                }

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

            typedef ZNsMain::
                ZtCCheckRef<TTypeHelp> ZCCheckRef;

            Type* VP_TypeArr = mp_TypeArr;

            __for0(TypeSize, i, ml_UseSize)
            {
                ZNsMain::ZtCTypeData<TFunctor>::GetObjRef(AO_Functor)
                    (
                        *VP_TypeArr, ZCCheckRef::PassData(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)
        {
            /*/////////////////////////////////////////////////////////////////////////////
            
            ■   TTypeHelp 가 class 일 경우, 크기가 커서 참조로 넘어가야 한다면,
            
                    IterElement<myFunctor, myClass&>(myFunctor_obj, myClass_Obj);

                의 형태로 호출할 게 아니라, ZNsMain::ZtCObjectPtr<> 을 사용하여,

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

                나

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

                형태를 사용하면 좋을 것 같다. -- 2014-06-16 23:11:00


                ZCCheckRef::PassData() 으로 인해, 인수를 ZtCRef 클래스를 이용해 인수를 참조
                로 넘길 수 있게 되었다. -- 2021-03-10 16:56

                이제는 ZtCRef 과 ZCCheckRef 클래스 템플릿을 사용하면 된다. -- 2021-03-11 11:00

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

            typedef ZNsMain::ZtCCheckRef<TTypeHelp1> ZCCheckRef1;
            typedef ZNsMain::ZtCCheckRef<TTypeHelp2> ZCCheckRef2;

            Type* VP_TypeArr = mp_TypeArr;

            __for0(TypeSize, i, ml_UseSize)
            {
                ZNsMain::ZtCTypeData<TFunctor>::GetObjRef(AO_Functor)
                (
                    *VP_TypeArr
                  , ZCCheckRef1::PassData(AO_TypeHelp1)
                  , ZCCheckRef2::PassData(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)*/


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

        ■  IterElement() 예제.

            #include <iostream>
            #include "ZCppMain/ZtCArray.H"


            using namespace std    ;
            using namespace ZNsMain;


            int main()
            {
                typedef ZtCArray<int>    CArray  ;
                typedef CArray::IterEasy IterEasy;


                CArray VO_Array;

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

                class CHelpObj
                {
                public:

                    CHelpObj()
                    {
                    }

                    CHelpObj(const CHelpObj& rhs)
                    {
                        cout<<"* CHelpObj(const CHelpObj& rhs)"<<endl;
                    }

                public:
                };  CHelpObj VO_CHelpObj; cout<<"VO_CHelpObj Ptr : "<<&VO_CHelpObj<<endl;

                struct StFunctor
                {
                    static void ShowElement(int ArgiValue){cout<<"#1 Value="<<ArgiValue<<endl;}
                };
                struct StFunctor2
                {
                    static void ShowElement(int ArgiValue, CHelpObj)
                        {cout<<"#2 Value="<<ArgiValue<<", CHelpObj Addr=None"<<" With CHelpObj"<<endl;}
                };
                struct StFunctor3
                {
                    static void ShowElement(int ArgiValue, CHelpObj& AR_CHelpObj)
                        {cout<<"#3 Value="<<ArgiValue<<", HelpObj Ptr="<<&AR_CHelpObj<<" With CHelpObj Ref"<<endl;}
                };
                struct StFunctor4
                {
                    static void ShowElement(int ArgiValue, CHelpObj& AR_CHelpObj)
                        {cout<<"#4 Value="<<ArgiValue<<", HelpObj Ptr="<<&AR_CHelpObj<<" With CHelpObj in Ptr"<<endl;}
                };
                struct StFunctor5
                {
                    static void ShowElement(int ArgiValue, CHelpObj& AR_CHelpObj, CHelpObj& AR_CHelpObj2)
                        {cout<<"#5 Value="<<ArgiValue<<", HelpObj Ptr="<<&AR_CHelpObj<<" With CHelpObj Ref 2"<<endl;}
                };
                struct StFunctor6
                {
                    static void ShowElement(int ArgiValue, CHelpObj& AR_CHelpObj, CHelpObj AO_CHelpObj2)
                        {cout<<"#6 Value="<<ArgiValue<<", HelpObj Ptr="<<&AR_CHelpObj<<" With CHelpObj Half Ref"<<endl;}
                };

                VO_Array.IterElement(StFunctor ::ShowElement);
                VO_Array.IterElement(StFunctor2::ShowElement, VO_CHelpObj );
                VO_Array.IterElement(StFunctor3::ShowElement, ZftMCR(VO_CHelpObj) );
                VO_Array.IterElement(StFunctor4::ShowElement, ZftMCP(VO_CHelpObj) );
                VO_Array.IterElement(StFunctor5::ShowElement, ZftMCP(VO_CHelpObj), ZftMCP(VO_CHelpObj) );
                VO_Array.IterElement(StFunctor6::ShowElement, ZftMCP(VO_CHelpObj),        VO_CHelpObj  );


                IterEasy VH_Iter = VO_Array.ItHEasy();

                __for1(int, i, VO_Array.size())
                {
                    cout<<i<<"th value="<<VO_Array.ItD(VH_Iter)<<endl;  VO_Array.ItNext(VH_Iter);
                }

                return 0;
            }

        ■  -- 2025-08-07 18:03:00

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


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

        ■  순차적으로 각 원소를 순회할 수 있는 자료 구조, 즉 리스트나 배열 클래스는

                MoveNextIter(),  MovePrevIter()

            멤버를 갖는 것으로 정했다. stl 의 반복자는 너무 일반화하다보니, 성능 상의
            제약이 발생한 것 같다.

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

            GetDataInIter() 를 추가했다.

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

        void MoveNextIter(Type*&            APR_CType    ) const{++APR_CType    ;}
        void MoveNextIter(iterator&         ARR_CIterator) const{++ARR_CIterator;}
        void MoveNextIter(IterEasyID&       AI_IterEasyID) const
            { MoveNextIter((Type*&)AI_IterEasyID); }
        void MoveNextIter(const Type*&      APR_CType    ) const{++APR_CType    ;}
        void MoveNextIter(const iterator&   ARR_CIterator) const{++ARR_CIterator;}
        void MoveNextIter(const IterEasyID& AI_IterEasyID)
            const{ MoveNextIter((const Type*&)AI_IterEasyID); }

        void MovePrevIter(Type*&            APR_CType    ) const{--APR_CType    ;}
        void MovePrevIter(iterator&         ARR_CIterator) const{--ARR_CIterator;}
        void MovePrevIter(IterEasyID&       AI_IterEasyID) const
            { MovePrevIter((Type*&)AI_IterEasyID); }
        void MovePrevIter(const Type*&      APR_CType    ) const{--APR_CType    ;}
        void MovePrevIter(const iterator&   ARR_CIterator) const{--ARR_CIterator;}
        void MovePrevIter(const IterEasyID& AI_IterEasyID)
            const{ MovePrevIter((const Type*&)AI_IterEasyID); }


        Type& GetDataInIter(Type*      AP_CType     ){return *AP_CType            ;}
        Type& GetDataInIter(iterator&  ARR_CIterator){return *ARR_CIterator       ;}
        Type& GetDataInIter(IterEasyID AI_IterEasyID){return *(Type*)AI_IterEasyID;}

        const Type& GetDataInIter(const Type*      AP_CType     ) const{return *AP_CType;}
        const Type& GetDataInIter(const iterator&  ARR_CIterator) const{return *ARR_CIterator;}
        const Type& GetDataInIter(const IterEasyID AI_IterEasyID) const
            { return *(const Type*)AI_IterEasyID; }


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

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


        Type*      ItHEasy  (){return          mp_TypeArr              ;}
        Type*      ItTEasy  (){return          mp_TypeArr+ml_UseSize-1 ;}
        IterEasyID ItHID(){return (IterEasyID) mp_TypeArr              ;}
        IterEasyID ItTID(){return (IterEasyID)(mp_TypeArr+ml_UseSize-1);}

        const Type*      ItHEasy  () const{return          mp_TypeArr              ;}
        const Type*      ItTEasy  () const{return          mp_TypeArr+ml_UseSize-1 ;}
        const IterEasyID ItHID() const{return (IterEasyID) mp_TypeArr              ;}
        const IterEasyID ItTID() const{return (IterEasyID)(mp_TypeArr+ml_UseSize-1);}

        void ItNext(Type*&            APR_CType    ) const{++APR_CType    ;}
        void ItNext(iterator&         ARR_CIterator) const{++ARR_CIterator;}
        void ItNext(IterEasyID&       AI_IterEasyID) const
            { ItNext((Type*&)AI_IterEasyID); }
        void ItNext(const Type*&      APR_CType    ) const{++APR_CType    ;}
        void ItNext(const iterator&   ARR_CIterator) const{++ARR_CIterator;}
        void ItNext(const IterEasyID& AI_IterEasyID)
            const{ ItNext((const Type*&)AI_IterEasyID); }

        void ItPrev(Type*&            APR_CType    ) const{--APR_CType    ;}
        void ItPrev(iterator&         ARR_CIterator) const{--ARR_CIterator;}
        void ItPrev(IterEasyID&       AI_IterEasyID) const
            { ItPrev((Type*&)AI_IterEasyID); }
        void ItPrev(const Type*&      APR_CType    ) const{--APR_CType    ;}
        void ItPrev(const iterator&   ARR_CIterator) const{--ARR_CIterator;}
        void ItPrev(const IterEasyID& AI_IterEasyID)
            const{ ItPrev((const Type*&)AI_IterEasyID); }

        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 TType               ,
                typename TTypArg=const TType&,
                typename TSize  =long
            >
    class ZtCArray /////////////////////////*/


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

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

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


    namespace ZNsExam
    {

        template<typename TDummy=void*> class ZtCExamArray
        {
        public:

        #ifndef _WIN

            class CHelpObj
            {
            public:

                CHelpObj()
                {
                }

                CHelpObj(const CHelpObj& rhs)
                {
                    cout<<"* CHelpObj(const CHelpObj& rhs)"<<endl;
                }

            public:
            };  CHelpObj VO_CHelpObj; cout<<"VO_CHelpObj Ptr : "<<&VO_CHelpObj<<endl;

            struct StFunctor
            {
                static void ShowElement(int ArgiValue){cout<<"#1 Value="<<ArgiValue<<endl;}
            };
            struct StFunctor2
            {
                static void ShowElement(int ArgiValue, CHelpObj)
                    {cout<<"#2 Value="<<ArgiValue<<", CHelpObj Addr=None"<<" With CHelpObj"<<endl;}
            };
            struct StFunctor3
            {
                static void ShowElement(int ArgiValue, CHelpObj& AR_CHelpObj)
                    {cout<<"#3 Value="<<ArgiValue<<", HelpObj Ptr="<<&AR_CHelpObj<<" With CHelpObj Ref"<<endl;}
            };
            struct StFunctor4
            {
                static void ShowElement(int ArgiValue, CHelpObj& AR_CHelpObj)
                    {cout<<"#4 Value="<<ArgiValue<<", HelpObj Ptr="<<&AR_CHelpObj<<" With CHelpObj in Ptr"<<endl;}
            };
            struct StFunctor5
            {
                static void ShowElement(int ArgiValue, CHelpObj& AR_CHelpObj, CHelpObj& AR_CHelpObj2)
                    {cout<<"#5 Value="<<ArgiValue<<", HelpObj Ptr="<<&AR_CHelpObj<<" With CHelpObj Ref 2"<<endl;}
            };
            struct StFunctor6
            {
                static void ShowElement(int ArgiValue, CHelpObj& AR_CHelpObj, CHelpObj AO_CHelpObj2)
                    {cout<<"#6 Value="<<ArgiValue<<", HelpObj Ptr="<<&AR_CHelpObj<<" With CHelpObj Half Ref"<<endl;}
            };

        #endif //#ifndef _WIN


            static int Main(int AI_ArgCnt=0, char* APP_ArgVal[]=0)
            {
                using namespace std    ;
                using namespace ZNsMain;

                typedef ZtCArray<int>    CArray  ;
                typedef CArray::IterEasy IterEasy;


                CArray VO_Array;

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


            #ifdef _WIN

                class CHelpObj
                {
                public:

                    CHelpObj()
                    {
                    }

                    CHelpObj(const CHelpObj& rhs)
                    {
                        cout<<"* CHelpObj(const CHelpObj& rhs)"<<endl;
                    }

                public:
                };  CHelpObj VO_CHelpObj; cout<<"VO_CHelpObj Ptr : "<<&VO_CHelpObj<<endl;

                struct StFunctor
                {
                    static void ShowElement(int ArgiValue){cout<<"#1 Value="<<ArgiValue<<endl;}
                };
                struct StFunctor2
                {
                    static void ShowElement(int ArgiValue, CHelpObj)
                        {cout<<"#2 Value="<<ArgiValue<<", CHelpObj Addr=None"<<" With CHelpObj"<<endl;}
                };
                struct StFunctor3
                {
                    static void ShowElement(int ArgiValue, CHelpObj& AR_CHelpObj)
                        {cout<<"#3 Value="<<ArgiValue<<", HelpObj Ptr="<<&AR_CHelpObj<<" With CHelpObj Ref"<<endl;}
                };
                struct StFunctor4
                {
                    static void ShowElement(int ArgiValue, CHelpObj& AR_CHelpObj)
                        {cout<<"#4 Value="<<ArgiValue<<", HelpObj Ptr="<<&AR_CHelpObj<<" With CHelpObj in Ptr"<<endl;}
                };
                struct StFunctor5
                {
                    static void ShowElement(int ArgiValue, CHelpObj& AR_CHelpObj, CHelpObj& AR_CHelpObj2)
                        {cout<<"#5 Value="<<ArgiValue<<", HelpObj Ptr="<<&AR_CHelpObj<<" With CHelpObj Ref 2"<<endl;}
                };
                struct StFunctor6
                {
                    static void ShowElement(int ArgiValue, CHelpObj& AR_CHelpObj, CHelpObj AO_CHelpObj2)
                        {cout<<"#6 Value="<<ArgiValue<<", HelpObj Ptr="<<&AR_CHelpObj<<" With CHelpObj Half Ref"<<endl;}
                };

            #endif //_WIN

                VO_Array.IterElement(StFunctor ::ShowElement);
                VO_Array.IterElement(StFunctor2::ShowElement, VO_CHelpObj );
                VO_Array.IterElement(StFunctor3::ShowElement, ZftMCR(VO_CHelpObj) );
                VO_Array.IterElement(StFunctor4::ShowElement, ZftMCP(VO_CHelpObj) );
                VO_Array.IterElement(StFunctor5::ShowElement, ZftMCP(VO_CHelpObj), ZftMCP(VO_CHelpObj) );
                VO_Array.IterElement(StFunctor6::ShowElement, ZftMCP(VO_CHelpObj),        VO_CHelpObj  );


                IterEasy VH_Iter = VO_Array.ItHEasy();

                __for1(int, i, VO_Array.size())
                {
                    cout<<i<<"th value="<<
                        VO_Array.ItD(VH_Iter)<<endl;

                    VO_Array.ItNext(VH_Iter);
                }
                ///////////////////////////////

                return 0;
            }/*
            static int Main(int AI_ArgCnt=0, char* APP_ArgVal[]=0)*/

        public:
        };/*
        template<typename TDummy=void*> class ZtCExamArray*/

    }/*
    namespace ZNsExam*/


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

    ■  class ZtCArrayOut<> 는 배열 메모리를 자체 할당하지 않고,
        이미 외부에서 new 나 정적으로 선언되어 있는 배열을 사용한다.
        따라서 ZtCArrayOut<> 내부에서 임의로 배열 크기를 조절할 수 없다.

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

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

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

        ZtCArrayOut()
        {
            Init(0, 0);
        }
        ZtCArrayOut(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*/

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

        위 코드를 아래로 하면 안된다.

        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 는 Type const * const 이지 Type const * 가 아니다.

        -- 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 TType,
                typename TSize=long
            >
    class ZtCArrayOut ///////////*/


    template< typename TTypeOjb, ZTypLong ATI_Length=1
            >
    class ZtCArrayStack //////////////////////////////
    {
    public :
        typedef TTypeOjb    TypeData  ;
        typedef ZTypLong    TypeSize  ;
    public :
        enum{ EAllSize=ATI_Length }   ;
    private:
        TypeData moa_Data[ATI_Length] ;
        TypeSize ml_UseSize           ; // moa_Data 의 실제 사용 길이
    public :

        ZtCArrayStack(TypeSize AL_StackSize)
        {
            ml_UseSize = 0;
        }/*
        ZtCArrayStack(TypeSize AL_StackSize)*/

        ZtCArrayStack& operator=(const ZtCArrayStack& rhs)
        {
            clear(); return (*this)(rhs.data(),rhs.size());
        }/*
        ZtCArrayStack& operator=(const ZtCArrayStack& rhs)*/

        ZtCArrayStack& operator()(const TypeData* AP_Data, TypeSize AL_Length)
        {
            if(AL_Length<1){ return *this; }

            if(AL_Length+ml_UseSize > EAllSize)
            {
                AL_Length = EAllSize - ml_UseSize;

                if(AL_Length<1) return *this;
            }/*
            if(AL_Length+ml_UseSize > EAllSize)*/

            TypeData* VP_Dest= moa_Data+ml_UseSize; const
            TypeData* VP_Src = AP_Data            ;

            ml_UseSize += AL_Length ;

            while(--AL_Length>=0)
                *VP_Dest++ = *VP_Src++ ;

            *VP_Dest=0; return *this;
        }/*
        ZtCArrayStack& operator()(const TypeData* AP_Data, TypeSize AL_Length)*/


        TypeSize GetSize() const
        {
            return ml_UseSize;
        }/*
        TypeSize GetSize() const*/

        TypeSize GetEmptySize() const
        {
            return EAllSize - ml_UseSize ;
        }/*
        TypeSize GetEmptySize() const*/

        TypeData* GetData()
        {
            return moa_Data;
        }/*
        TypeData* GetData()*/

        const TypeData* GetData() const
        {
            return moa_Data;
        }/*
        const TypeData* GetData() const*/


        void MemCopy(TypeData* AP_Data, TypeSize AL_Length)
        {
            if(AL_Length<1 || ml_UseSize<1)
                return;
            if(AL_Length>=ml_UseSize      )
                ::memcpy(AP_Data, moa_Data, sizeof(TypeData)*ml_UseSize);
            else
                ::memcpy(AP_Data, moa_Data, sizeof(TypeData)*AL_Length );
          //else
        }/*
        void MemCopy(TypeData* AP_Data, TypeSize AL_Length)*/


        TypeSize size() const
        {
            return ml_UseSize;
        }/*
        TypeSize size() const*/

        TypeData* data()
        {
            return moa_Data;
        }/*
        TypeData* data()*/

        const TypeData* data() const
        {
            return moa_Data;
        }/*
        const TypeData* data() const*/

        void clear()
        {
            // add codes
        }/*
        void clear()*/

    public:
    };/*
    template< typename TTypeOjb, typename ZTypLong ATI_Length=1
            >
    class ZtCArrayStack /////////////////////////////////////*/


}/*
namespace ZNsMain*/


#endif //__ZCPPMAIIN__ZTCARRAY_H__