RepoMain/ZCppMain/ZMainHead.H



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

■  unsigned 정수형은 가급적이면 쓰지 말자. 일반적으로 많이 쓰는 signed 정수와의 호환이
    '약간' 거슬리고 있는데, 이 '약간' 이라도 왠지 찝찝하다. 2008-09-14 03:24:00

■  해당 namespace 에서 필요한 상수는 그 namespace 안에서 상수전용 namespace ZNsConst 를
    만들고 그 안에 둔다.

    해당 namespace 에서 필요한 enum 는 그 namespace 안에서 enum 전용 namespace ZNsEnum 를
    만들고 그 안에 둔다. 해당 enum 형을 문자열로 돌려주는 함수는, 동일한 네임스페이스 안
    에

        const char* GetMSG_enum_data_type(int            AI_Enum);
        const char* GetMSG_enum_data_type(enum_data_type AE_Enum);

    의 형태로 설계한다.

    --

    필요하면 ZNsEnum, ZNsConst 를 접두어로 하는 namespace 를 만들고 그 안에서 필요한 enum
    자료형이나 상수형을 정의할 수 있다.

    -- 2010-06-13 22:37:00

■  해당 namespace 에서 특정 클래스에 필요한 단순히 인터페이스를 알리주는 클래스나 함수는
    그 namespace 안에서 interface 전용 namespace ZNsIFace 를 만들고 그 안에 둔다. 멤버
    변수가 없이 순수 interface 로만 사용되는 클래스는 'C' 가 아닌 'I' 로 시작한다.

■  복잡한 템플릿 인수 타입 관계를 정리하기 위해 사용하는 class 에는 ZtCType 이라는 접두어
    를 붙이고 모두 namespace ZNsType 에 둔다.

■  주로 예제 용도로 작성하는 클래스는 namespace ZNsExam 에 둔다. 주로 복잡한 템플릿 인수
    를 가지는 클래스에 대한 예제일 것이다.

■  복잡한 템플릿 인수 타입 관계를 정리하기 위해 Proxy 로 사용하는 class 에는 CProxy 이라
    는 접두어를 붙이고 모두 namespace ZNsIProxy 에 둔다.(Interface Proxy) 실제 Proxy 를 구
    현하는 클래스는 CProxy 라는 접두어를 붙이고 namespace ZNsProxy 안에 둔다.

    ZNsIProxy 와 ZNsProxy 를 다른 용도로 쓰고 있는 것이다.

■  특정 클래스 안에서만 사용되어 사용자가 그 존재를 알 필요가 없는 클래스는

        namespace ZNsHide

    에 둔다.

■  같은 이름의 일반 함수와 템플릿 함수가 있어면 좋은 상황에서 하는데, 함수를 일반 함수와
    템플릿 함수로 중첩시키기가 힘들 때, 템플릿 함수를 일반함수가 속한 namespace 안에 또
    다른 namespace ZNsTmpl 에 둔다.

    cf) std::ZNsTmpl::FindPos();

■  어떤 클래스(템플릿)이 거의 같은 기능을 하지만, Decoration 패턴을 사용하는 클래스와,
    그렇지 않은 클래스가 쌍으로 존재할 때, Decoration 패턴을 사용하는 클래스는 주로
    
        namespace ZNsDeco

    에 둔다. Decoration 패턴은 Logic 과 View 구조에서, View 에 해당하는 클래스를, Logic
    클래스 의 생성자에서 (주로) 참조로 전달받는 경우를 말한다.

■  클래스 템플릿 설계할 때 핵심 기능만 구현하고 나머지 부분은 기초클래스나 상속클래스,
    혹은 멤버가 되는 클래스로 설계할 수 있는데, 이 클래스들의 이름에 적절한 이름을 붙이기
    어려운 경우에는 CHelp~ 로 시작하는 이름으로 하자. 이외에도 Business Logic 과 View 의
    분리라는 뜻에서 CView~  도 생각할 수 있다.

    cf) class CHelpIOCP

■  template 으로 어떤 main class 를 디자인할 때 다른 class template 을 인수로 받는 경우
    가 있겠고 이때 클래스 템플릿 인수의 instance 의 멤버를 셋팅하려면 그 template 의 모든
    멤버에 대하여 public 권한을 갖게 되는 경우가 많을 것이다. 이때는 셋팅 권한을 갖는 멤
    버를 외부 기초 클래스 template 으로 만들고(따라서 main class 는 이 기초클래스를 상속
    한다.) 이 class 에서 friend 지정을 하면 될 것이다. 그런데 main class 도 템플릿일 것으
    므로 기초 클래스가 정의되기 전에는 정의될 수 없다는 문제가 있다. 이 문제를 피하기 위
    해 main class 를 상속하는 비템플릿 클래스를 선언하고 (정의는 나중으로 미루고 전방선언
    만 한다.) 기초 클래스에서 이 클래스에 friend 지정을 하면 될 것이다.

    아니면 public 이 아니어야 할 멤버 함수가 템플릿 설계로 인해 어쩔 수 없이 public 으로
    해야 할때 No Public 을 의미하는 macro _NP_ 를 그 함수 선언과 정의 앞에 붙여주자

■  함수가 어떤 조건에서 실행을 중지할 때, bool 값으로 표시해도 되지만 가독성을 위해서

        enum std::ZNsEnum::ZERun
        
    을 사용하자.

■  함수가 굳이 어떤 값을 리턴할 필요는 없는데, 함수의 역할이 특정 조건인지 체크해서 그
    조건에 맞으면 어떤 작업을 실행한다고 할 때, 이 실행 여부를 굳이 리턴하고자 한다면 bool
    형 대신에, 가독성을 위해서 enum std::ZNsEnum::EAct 을 사용하자.

■  call back 함수나 이떤 이벤트마다 실행하는 함수는 접두어 'On' 을 붙이자. 어떤 컨테이너
    의 각 원소마다 특정한 처리를 하는 함수에는 'Iter' 를 붙이자.

    cf) CDoubleList<int>::IterElement();

    'Iter' 대신에 'OnEach' 를 붙여도 좋을 것 같다.

■  클래스의 초기와, 종료함수를 별도로 지정할 때에는 각각 접두어 Init, Fini 뒤에 적절한
    이름을 붙여주자. 클래스의 초기와, 종료함수를 Init, Fini 로만 지정했더니, 나중에는 비
    슷비슷한 이름이 많아서 상속할 때 상당히 햇깔렸다.

    클래스의 멤버중에 단순히 멤버를 0 과 같은 초기값으로 셋팅하는 함수는 InitVar 라는 함
    수명을 사용하자.

■  containter class template 는 TypeData 라는 type 을 가져야 한다. 예를 들어

        CObjList<int>::TypeData
        
    라는 접근이 가능해야 한다. 이 표기에서 int 가 TypeData 라는 것은 분명히 알 수 있으나
    containter 형을 인수로 받는 템플릿에서, 그 템플릿이 어떤 자료형 (예에서는 int)에 대한
    containter 인지 모르게 된다. 이것을 해결하기 위한 (템플릿을 편리하게 하기 위한)규칙이
    다.

    이외에도 컨테이너의 컨테이너와 같은 복잡한 컨테이너 type 을 템플릿 인수로 여러 개 갖
    는 컨테이너에서 TypeData 외에 추가적인 정의를 할 수 있겠다. 이런 type 이 이름은 Type
    으로 시작하는 것으로 하자.

        cf) IN ZNsCPP::CStringSerial_T<>

        typedef TTypeCh     TypeData        ;
        typedef TStringType TypeCStringData ;
        typedef TStringList TypeCStringList ;

    ※  그런데 꼭 container class template 가 아니라 할지라도 class template 은 내부적으
    로 대표 자료형 TypeData 형을 갖도록 하는 것이 좋을 것 같다. 2008-11-05 13:22:00

    ※  TString 에 외부 접근 형 정의를 한다면 TypeCString 이 아니라 TypeString 으로 하는
    것이 좀 예쁜(?) 것 같다.

        typedef TString TypeCString;
        typedef TString TypeString ;

    2 번 줄 코드가 좀 낳아 보이지 않을까. 2008-11-05 13:42:00

■  template 함수나 클래스에서 functor 인수는 참조로 선언하지 않는다. 아래 참고,

        InputIterator& first, InputIterator& last
        
    이라고 하지 않았다. 단순 함수나 크기가 작은 object 일 경우 느려질 수 있기 때문이다.
    단 아래 for_each 예에서 InputIterator 가 클래스일 경우 복사 생성자를 꼭 가져야 한다.

        template<class InputIterator, class Function>
        Function for_each(InputIterator first, InputIterator last, Function f)
        {
            while ( first!=last ) f(*first++);
            return f;
        }

■  WINDOW 에서 UNICODE 로 컴파일할 경우 아래 3 개의 매크로를 추가할 것.

    #define _MBCS
    #define _UNICODE
    #define UNICODE

■  구 버전의 컴파일러에서 RTTI 옵션이 꺼져 있으면 헤더파일 typeinfo 을 사용할 수 없다.


■  breakpoint assembly

    _asm
    {
        int 3;
    }

■  리눅스 core file 무제한 명령

    ulimit -c unlimited
    system("ulimit -c unlimited");

■  Visual C++ 2008 에 추가된 함수를 사용할려면 아래 매크로를 정의한다.

    #define _WIN32_WINNT 0x0600

    -- 2010-04-22 19:55:00

■  _REENTRANT_EX 매크로를 정의하면 _REENTRANT 보다 좀더 최적화된 thread-safe 함수를
    사용하거나, 약간 실험적인 thread-safe 함수를 사용한다.

    -- 2011-03-13 01:04:00

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


#ifndef __ZCPPMAIIN_ZMAINHEAD_H__
#define __ZCPPMAIIN_ZMAINHEAD_H__


#include <cstdio>
#include <cstdarg>
#include <cstdlib>
#include <cstring>
#include <string>
#include <climits>
#include <typeinfo>


#define _CODE_OLD_ 0
#define _CODE_BAD_ 0
#define _CODE_NEW_ 1

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

■  위 매크로 _CODE_OLD_ 와 _CODE_NEW_ 등은 #if(0) 이나 #if(1) 등으
    로 폐기되거나 추가된 코드를 나타냈던 것을 좀 더 직관적으로 표현
    한다.

    -- 2013-07-28 16:21:00

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


#define _COMMENT_  0 // 주석으로 사용하는 부분.


#if defined(_WIN32) || defined(_WIN64) || defined(_WIN128) || \
    defined( WIN32) || defined( WIN64) || defined( WIN128)

    #ifndef _WIN
    #define _WIN
    #endif

#endif/*
    defined(_WIN32) || defined(_WIN64) || defined(_WIN128) || \
    defined( WIN32) || defined( WIN64) || defined( WIN128) */


#if defined(_WIN64) || defined( WIN64)
    #ifndef __CPU_BIT_CNT__
    #define __CPU_BIT_CNT__ 64
    #endif
#endif /*defined(_WIN64) || defined( WIN64) */

#if defined(_WIN128) || defined( WIN128)
    #ifndef __CPU_BIT_CNT__
    #define __CPU_BIT_CNT__ 128
    #endif
#endif /*defined(_WIN128) || defined(WIN128) */


#if defined(_WIN)

    typedef   signed char     int8_t ;
    typedef unsigned char    uint8_t ;

    typedef   signed short    int16_t;
    typedef unsigned short   uint16_t;

    typedef   signed int      int32_t;
    typedef unsigned int     uint32_t;

    typedef   signed __int64  int64_t;
    typedef unsigned __int64 uint64_t;

    #ifndef __VISUAL_CPP_VER__
    #define __VISUAL_CPP_VER__ 200800 // 끝 2 자리는 소수점 버전
    #endif//__VISUAL_CPP_VER__

#elif defined(__mips__)

    typedef   signed char       int8_t ;
    typedef unsigned char      uint8_t ;

    typedef   signed short      int16_t;
    typedef unsigned short     uint16_t;

    typedef   signed int        int32_t;
    typedef unsigned int       uint32_t;

    typedef   signed long long  int64_t;
    typedef unsigned long long uint64_t;

#else
    #include <stdint.h>
#endif


#if defined(_WIN)
    #define _STRUCT_PACK_
    #ifndef __STD_CALL__
        #define __STD_CALL__ __stdcall
    #endif
#elif defined(__unix__)
    #define _STRUCT_PACK_  __attribute__((packed))
    #ifndef __STD_CALL__
        #define __STD_CALL__
    #endif
#elif defined(__linux__)
    #define _STRUCT_PACK_  __attribute__((packed))
    #ifndef __STD_CALL__
        #define __STD_CALL__
    #endif
#else
    #define _STRUCT_PACK_  __attribute__((packed))
    #ifndef __STD_CALL__
        #define __STD_CALL__
    #endif
#endif

#ifdef _REENTRANT_EX
    #ifndef _REENTRANT
    #define _REENTRANT
    #endif
#endif

#if defined(_REENTRANT)
    #ifndef _REENTRANT_MUTEX
    #define _REENTRANT_MUTEX
    #endif //_REENTRANT_MUTEX
    #define _REENTRANT_BOOL_ 1
#else
    #define _REENTRANT_BOOL_ 0
#endif //_REENTRANT


#ifdef _WIN

    #pragma warning(disable:4503)
    #pragma warning(disable:4786)
    #pragma warning(disable:4996)
    #pragma warning(disable:4244)
    #pragma warning(disable:4267)
    #pragma warning(disable:4018)
    #pragma warning(disable:4312)
    #pragma warning(disable:4290)
    #pragma warning(disable:4076)

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

    ■  4290 경고 : 함수 선언에 throw 가 있다.

        warning C4290: 함수가 __declspec(nothrow)가 아님을 나타내려는 경우를 제외하고 C++ 예외 사양은 무시됩니다.
        warning C4290: C++ exception specification ignored except to indicate a function is not __declspec(nothrow)

        -- 2013-07-08 02:39:00

    ■  4076 경고 :  wchar_t 에 unsigned 를 지정했다. 리눅스에서는 어떤 경고도 없다.

        warning C4076: 'unsigned' : can not be used with type 'wchar_t'

        -- 2013-07-08 02:45:00

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


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

    ■  WinSock2.h 파일이 include 되기 전에, windows.h 파일이 include 돼서는 안된다.
        WinSock2.h 이 필요하면, 이 파일 MainHeader 보다 먼저 include 해야 한다.

    ■  TCHAR.H 파일을 include 하고 _MBCS 와 _UNICODE 가 정의되어 있으면
        TCHAR 이 wchar_t 으로 정의되어야 하나, VC++ 6.0 에서는 자꾸 char 로 정의된다.

        -- 2006-10-12 09:53:00

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

    #include <TCHAR.H>
    #include <WinSock2.h>
    #include <windows.h>

    // 아래 pragma 코드가 이미 CNet_Win.H 에 있는데, 필요하면 아래 주석을 제거한다.
    //
    // #pragma comment(lib, "ws2_32")


    #ifndef _T
        #define _T(X) X
    #endif


    #if      defined(__VISUAL_CPP_VER__) && __VISUAL_CPP_VER__<200000

    // VC++ 6.0 에서는 아래 선언이 필요.
    // VC++ 7.0 부터는 주석처리 할 것.

    typedef unsigned long  ULONG_PTR ;
    typedef unsigned long* PULONG_PTR;

    #endif //defined(__VISUAL_CPP_VER__) && __VISUAL_CPP_VER__<200000

#else // !defined(_WIN)

    #include<errno.h>

    #if defined(UNICODE) || defined(_UNICODE)
        #define LPCTSTR const wchar_t*
    #else
        #define LPCTSTR const char*
    #endif

    #ifndef _T
        #define _T(X) X
    #endif

    #define LONG long

#endif // !defined(_WIN)


#if defined(_REENTRANT)

    #if defined(__linux__)

        // 리눅스 Multi Thread Programming 에서 ZCObjList 라든가 여러
        // 자료구조에서 쓰는 동기화 뮤텍스를 위해 pthread.h 를 포함한다.

        #include <pthread.h>

    #elif defined(__unix__)
        #include <pthread.h>
    #elif defined(__sun__) // In Solaris
        #include <pthread.h>
    #elif defined(_WIN)
        //Don't inclucde
    #else
        #include <pthread.h>
    #endif

#endif //defined(_REENTRANT)


#ifdef _DEBUG
    #include<iostream>
    #include<fstream>
#endif


using namespace std;


#define RR(RefReceive) RefReceive

    // RR 메크로는 인수가 참조를 전달하고 다시 어떤 값으로 설정받는다는 것을 뜻함


#define _NP_

    /*  템플릿의 멤버함수가 원래는 public 가 아니어야 하지만,
        템플릿 설계상 어쩔 수 없이 public 으로 했음을 의미. No Public */


#define _VT_

    // _VT_ 메크로는 주로 상속해서 사용하는 멤버함수를 의미


#define _SY_

    /*  동기화(Sync) 영역에서 호출되는 함수를 의미. 따라서 이 함수안에서
        같은 동기화 object 를 사용하는 함수를 호출하지 않도록 주의한다. */

#define _BETA_

    /*  beta 테스트 중이거나, 실제로 사용하기에는 기술적인 문제가
        잠재해 있는 함수를 의미. (2011-04-03 21:37:00)            */


#ifdef __CYGWIN__
    #define atoll atol /*for Cygwin*/
#endif


#define __for0(IntType, i, LoopCount)  for(IntType i=0; i< LoopCount; ++i)
#define __for1(IntType, i, LoopCount)  for(IntType i=1; i<=LoopCount; ++i)

#define __forD0(i, LoopCount)  for(i=0; i< LoopCount; ++i) // 정수형 선언이 미리 있는 경우. D 는 Declare.
#define __forD1(i, LoopCount)  for(i=1; i<=LoopCount; ++i)



namespace ZNsMain
{

    typedef int      ZTypInt     ;
    typedef int      ZTypIntE    ; // int enum : 다른 enum 형끼리 비교할 일이 있을 때, 이 자료로 형변환한다.
    typedef int      ZTypIntEnum ;
    typedef long     ZTypIntLong ;
    typedef short    ZTypIntShort;

    typedef int      ZTypIntI    ; // 정수를 가장 잘 대표할 수 있는 자료형. 필요에 따라 long 이나 short 으로 typedef 할 수도 있다.
    typedef long     ZTypIntL    ;
    typedef short    ZTypIntS    ;

    typedef long     ZTypLong    ;
    typedef short    ZTypShort   ;

    typedef int8_t   ZTypInt8    ;
    typedef int16_t  ZTypInt16   ;
    typedef int32_t  ZTypInt32   ;
    typedef int64_t  ZTypInt64   ;

    typedef uint8_t  ZTypUInt8   ;
    typedef uint16_t ZTypUInt16  ;
    typedef uint32_t ZTypUInt32  ;
    typedef uint64_t ZTypUInt64  ;

    typedef uint8_t  ZTypIntU8   ;
    typedef uint16_t ZTypIntU16  ;
    typedef uint32_t ZTypIntU32  ;
    typedef uint64_t ZTypIntU64  ;

    #if defined(UNICODE) || defined(_UNICODE)

        typedef wchar_t           ZTypXCHAR   ;
        typedef wchar_t           ZTypXChar   ;

        typedef wchar_t*          ZTypXPChar  ;
        typedef const wchar_t*    ZTypXCPChar ;
    #else

        typedef char              ZTypXCHAR   ;
        typedef char              ZTypXChar   ;

        typedef char*             ZTypXPChar  ;
        typedef const char*       ZTypXCPChar ;
    #endif


    typedef char                  ZTypChar    ;
    typedef wchar_t               ZTypCharW   ;

    typedef const char            ZTypCChar   ;
    typedef const wchar_t         ZTypCCharW  ;

    typedef       char*           ZTypPChar   ;
    typedef const char*           ZTypCPChar  ;
    typedef       char* const     ZTypPCChar  ;
    typedef const char* const     ZTypCPCChar ;

    typedef       char*           ZTypPCh     ;
    typedef const char*           ZTypCPCh    ;
    typedef       char* const     ZTypPCCh    ;
    typedef const char* const     ZTypCPCCh   ;

    typedef       wchar_t*        ZTypPWChar  ;
    typedef const wchar_t*        ZTypCPWChar ;
    typedef       wchar_t* const  ZTypPWCChar ;
    typedef const wchar_t* const  ZTypCPCWChar;

    typedef       wchar_t*        ZTypPWCh    ;
    typedef const wchar_t*        ZTypCPWCh   ;
    typedef       wchar_t* const  ZTypPWCCh   ;
    typedef const wchar_t* const  ZTypCPCWCh  ;

    typedef unsigned char         ZTypUChar   ;

    #if(0)

    typedef unsigned wchar_t      ZTypUWCha   ;
        /* VC++ 2012 에서는 여기서 4076 번 경고가 발생한다.

            warning C4076: 'unsigned' : can not be used with type 'wchar_t'

          Linux g++ 4.4.7 에서는 unsigned wchar_t 를 잘 인식하고 있다.

         */
    #endif

    typedef unsigned int       ZTypUInt       ;
    typedef unsigned short     ZTypUShort     ;
    typedef unsigned long      ZTypULong      ;
 
    typedef unsigned char      ZTypIntUChar   ;
    typedef unsigned int       ZTypIntUInt    ;
    typedef unsigned short     ZTypIntUShort  ;
    typedef unsigned long      ZTypIntULong   ;

    typedef unsigned char      ZTypIntUC      ;
    typedef unsigned int       ZTypIntUI      ;
    typedef unsigned short     ZTypIntUS      ;
    typedef unsigned long      ZTypIntUL      ;

#if(defined(__CPU_BIT_CNT__) && __CPU_BIT_CNT__>=64)
    #ifdef _WIN
        typedef __int64        ZTypLength     ; // 문자열의 길이를 나타내는 자료형.
                                              //  송수신 버퍼의 크기 자료형으로도 쓰인다.
        typedef unsigned __int64  ZTypULen    ;
        typedef unsigned __int64  ZTypULength ;
    #else
        typedef long           ZTypLength     ;
        typedef unsigned long  ZTypULen       ;
        typedef unsigned long  ZTypULength    ;
    #endif
#else  // !defined(__CPU_BIT_CNT__) || __CPU_BIT_CNT__<64

    typedef long               ZTypLength     ;
    typedef unsigned long      ZTypULen       ;
    typedef unsigned long      ZTypULength    ;

#endif // !defined(__CPU_BIT_CNT__) || __CPU_BIT_CNT__<64

#ifdef _WIN
    typedef __int64            ZTypLengthFile ; // 파일의 크기를 나타내는 자료형.
#else
    typedef long               ZTypLengthFile ; // 파일의 크기를 나타내는 자료형.
#endif
    typedef ZTypLengthFile     ZTypLengthF    ;


#ifdef _WIN
    typedef          __int64   ZTypLongLong   ;
    typedef unsigned __int64   ZTypULongLong  ;

    typedef          __int64   ZTypIntLLong   ;
    typedef unsigned __int64   ZTypIntULLong  ;
#else
    typedef          long long ZTypLongLong   ;
    typedef unsigned long long ZTypULongLong  ;

    typedef          long long ZTypIntLLong   ;
    typedef unsigned long long ZTypIntULLong  ;
#endif


    typedef ZTypLongLong       ZTypLLong      ;
    typedef ZTypULongLong      ZTypULLong     ;

    typedef ZTypLongLong       ZTypIntLL      ;
    typedef ZTypULongLong      ZTypIntULL     ;


    #ifdef _WIN64
        typedef __int64          ZTypIntPtr   ; // 포인터를 표현하는      정수 크기다.
        typedef unsigned __int64 ZTypIntUPtr  ; // 포인터를 표현하는 양의 정수 크기다.
    #else
        typedef long             ZTypIntPtr   ;
        typedef unsigned long    ZTypIntUPtr  ;
    #endif


    typedef const int         ZTycInt    ;
    typedef const int         ZTycIntI   ;
    typedef const long        ZTycLong   ;
    typedef const long        ZTycIntL   ;
    typedef const short       ZTycShort  ;
    typedef const short       ZTycIntS   ;
    typedef const char        ZTycChar   ;
    typedef const wchar_t     ZTycCharW  ;

    typedef const ZTypLLong   ZTycLLong  ;
    typedef const ZTypULLong  ZTycULLong ;

    typedef const ZTypIntLL   ZTycIntLL  ;
    typedef const ZTypIntULL  ZTycIntULL ;

    typedef const ZTypIntPtr  ZTycIntPtr ;
    typedef const ZTypIntUPtr ZTycIntUPtr;
    
    typedef const char        ZTycChar   ;
    typedef const wchar_t     ZTycWChar  ;

    typedef const char*       ZTycPChar  ;
    typedef const wchar_t*    ZTycPWChar ;


    #ifdef _WIN32
        typedef HANDLE  ZTypeID;
    #else
        typedef int     ZTypeID;
    #endif


    typedef class ZCIterEasy{} IterEasy, *IterEasyID ;
    typedef const IterEasyID              IterEasyIDc;

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

    ■  typedef class CIterEasy{} *IterEasyID
    
        CObjList<> 등에서 사용하는 반복자로 사용하는 자료형이다. 반복자를 사용할 때마
        다, typedef typename std::CObjList<>::IterEasy IterEasy 등으로 길게 선언해야
        하는 것이 성가셨다.

        -- 2013-06-02 08:44:00

        CObjList.H 등에서 관련 멤버 함수를 추가하고, CHttp.H 와 CHttp2.H 의 기존 ZCLink
        를 사용하는 코드를 IterEasyID 을 사용하는 코드로 적절히 반영한 결과, 숨어 있던
        버그를 발견하고 조치한 듯한, 맑은 기분을 느낄 수 있었다.

        -- 2013-06-02 12:13:00

        CStringEx.H 파일에도 반영했다. -- 2013-06-02 09:59:00

    ■  IterEasyIDc 선언을

            typedef const IterEasyID IterEasyIDc;

        라 하면, 천만 뜻밖에도 IterEasyIDc 의 type 이름

            typeid(IterEasyIDc).name() 으로 구한 값

        이 IterEasyID 의 name() 값과 같다.

        -- 2015-11-07 21:34:00
    
    ///////////////////////////////////////////////////////////////////////////////*/



    class ZCEndian
    {
    private:
        static const unsigned int         SUI_Int ;
        static const unsigned char* const SPC_Char;
    public :
        static const bool SB_IsBig    ;
        static const bool SB_IsLittle ;
    public :
    };/*
    class ZCEndian*/

    const unsigned int         ZCEndian::SUI_Int  = 1 ;
    const unsigned char* const ZCEndian::SPC_Char =
        reinterpret_cast<const unsigned char*>(&ZCEndian::SUI_Int)  ;

    const bool ZCEndian::SB_IsBig    = (int(ZCEndian::SPC_Char[0]) ==1 ) ;
    const bool ZCEndian::SB_IsLittle = (int(ZCEndian::SPC_Char[0]) !=1 ) ;


    class ZCEmpty
    {
        /*///////////////////////////////////////////////////////////////////////////

        ■  템플릿 정의에서 비어있는 클래스를 요구하는 경우가 있다.

        ■  또한 여러 개의 템플릿 인자를 가진 클래스 템플릿의 특정 인자에 대하여 부분
            특수화를 하는 경우, 부분 특수화 되는 인수의 type 을, 특수화되지 않는 최초
            의 템플릿 정의 부분에서 무엇으로 할 지 고민되는 경우가 있다면, 이때 고민
            하지 말고 ZCEmpty 를 써버리자.

            -- 2010-05-04 02:29:00

            어, 근데 템플릿 인자에 void 를 사용할 수도 있다. 이것을 다소 늦게 알았는데,
            그래도 비어 있는 클래스를 상속할 경우, 커파일러가 크기를 0 으로 해놓는 장점
            이 있으니까 일단 그냥 둔다. 만약 void 를 사용하게 되면, void 를 템플릿 인자
            로 사용하는 버전과 사용하지 않는 버전으로 항상 정의를 해주어야 하는 성가신
            점이 있다.

            -- 2012-09-01 17:26:00

        ///////////////////////////////////////////////////////////////////////////*/
    };/*
    class ZCEmpty*/


    namespace ZNsIFace
    {
        // 이 이름 공간안에 interface 가 되는 class (템플릿) 가 온다.
    }/*
    namespace ZNsIFace*/


    namespace ZNsIFaceEx
    {
        // ZNsIFace   에는 주로 interface 가 있다면,
        // ZNsIFaceEx 에는 실제로 동작하는 코드가 온다.
        // 따라서 여기에 오는 클래스는 주로 ZNsIFace 에 이미 있는 것이다.
        // 다만, ZNsIFace   의 클래스는 주로 ZI 로 시작한다면
        //       ZNsIFaceEx 의 클래스는 주로 ZC 로 시작한다.
        // -- 2025-09-13 01:06
    }/*
    namespace ZNsIFaceEx*/


    namespace ZNsEnum
    {

        // ECompareResult 는 어떤 두 개의 값을 비교한 결과를 표시한다.
        // ZftGetCompareCode() 나 class ZtCCompare<> 에서 사용할 것이다.

        enum ZECompareResult
        {
            ZECompareResult_Equal= 0, // 서로 같다.
            ZECompareResult_More = 1, // 왼쪽이 크다.
            ZECompareResult_Less =-1  // 오른쪽이 크다.
        };/*
        enum ZECompareResult*/

    }/*
    namespace ZNsEnum*/


    template<typename ZtpChar, typename ZtpiLength> ZTypIntE ZftGetCompareCode
        (
            const ZtpChar* ZApcLeft , ZtpiLength ZAiLenLeft ,
            const ZtpChar* ZApcRight, ZtpiLength zAiLenRight
        )
    /*######################################################################*/
    {
        if(ZAiLenLeft<1 && zAiLenRight<1)
            return ZNsEnum::ZECompareResult_Equal;

        ZtpiLength ViLoopCnt =
            (ZAiLenLeft<=zAiLenRight ? ZAiLenLeft : zAiLenRight);

        __for0(ZtpiLength, i, ViLoopCnt)
        {
            if(ZApcLeft[i] > ZApcRight[i]) return ZNsEnum::ZECompareResult_More;
            if(ZApcLeft[i] < ZApcRight[i]) return ZNsEnum::ZECompareResult_Less;
        }/*
        __for0(ZtpiLength, i, ViLoopCnt)*/

        if(ZAiLenLeft==zAiLenRight) return ZNsEnum::ZECompareResult_Equal;
        if(ZAiLenLeft> zAiLenRight) return ZNsEnum::ZECompareResult_More ;
        if(ZAiLenLeft< zAiLenRight) return ZNsEnum::ZECompareResult_Less ;

        return ZNsEnum::ZECompareResult_Equal;
    }/*
    template<typename ZtpChar, typename ZtpiLength> ZTypIntE ZftGetCompareCode
        (
            const ZtpChar* ZApcLeft , ZtpiLength ZAiLenLeft ,
            const ZtpChar* ZApcRight, ZtpiLength zAiLenRight
        )
    /*######################################################################*/


    /*  어떤 변수를 강제적으로 참조로 인식하게 하는 클래스. 인수를 참조로
        넘어가게 하고 싶을 때 사용한다. class ZtCCheckRef 에서 사용하고 있다.
        -- 2021-04-10 16:15
    */
    template<typename TTypType> class ZtCRef
    {
    public :
        typedef TTypType& TypeData ;
        typedef TTypType& TypeRef  ;
        typedef TTypType  TypeRaw  ;
        typedef TTypType  TypeConst;
    private:
        TypeData mr_Data;
    public :
        ZtCRef(TypeData AR_TypeData) : mr_Data(AR_TypeData){}
    public :
        TypeData GetData(){return mr_Data;}
    public :
    };/*
    template<typename TTypType> class ZtCRef*/

    template<typename TTypType> class ZtCRef<TTypType&>
    {
    public :
        typedef       TTypType& TypeData ;
        typedef       TTypType& TypeRef  ;
        typedef       TTypType  TypeRaw  ;
        typedef const TTypType& TypeConst;
    private:
        TypeRaw& mr_Data;
    public :
        ZtCRef(TypeRef AR_TypeData) : mr_Data(AR_TypeData){}
    public :
        TypeRef GetData(){return mr_Data;}
    public :
    };/*
    template<typename TTypType> class ZtCRef<TTypType&>*/

    template<typename TTypType> class ZtCRef<const TTypType&>
    {
    public :
        typedef const TTypType& TypeData ;
        typedef const TTypType& TypeRef  ;
        typedef const TTypType  TypeRaw  ;
        typedef const TTypType& TypeConst;
    private:
        TypeRaw& mr_Data;
    public :
        ZtCRef(TypeRef AR_TypeData) : mr_Data(AR_TypeData){}
    public :
        TypeRef GetData(){return mr_Data;}
    public :
    };/*
    template<typename TTypType> class ZtCRef<const TTypType&>*/


    template<typename TTypType> inline ZtCRef<TTypType>
        ZftMakeCRef(TTypType& AR_TypeData){ return  ZtCRef<TTypType>  (AR_TypeData );}
    template<typename TTypType> inline ZtCRef<TTypType>*
        ZftMakeCPtr(TTypType& AR_TypeData){ return (ZtCRef<TTypType>*)(&AR_TypeData);}
    /*////////////////////////////////////////////////////////////////////////////////

    ■  ZftMakeCPtr() 은 인수 AR_TypeData 이 ZtCRef<TTypType>* 인 것처럼 반환한다.

      그래서 template<typename TType> class ZtCCheckRef< ZtCRef<TType>* > 에서 사용할
      것이다.

      -- 2025-08-07 17:16

    ■  사용례는 ZCppMain/ZtCArray.H 의 IterElement() 의 주석에 있다.

    ■  아래 ZftMCR() 와 ZftMCP() 는 위 함수명을 더 축약한 것이다. -- 2025-08-07 17:41

    ////////////////////////////////////////////////////////////////////////////////*/
    template<typename TTypType> inline ZtCRef<TTypType>
        ZftMCR(TTypType& AR_TypeData){ return  ZtCRef<TTypType>  (AR_TypeData );}
    template<typename TTypType> inline ZtCRef<TTypType>*
        ZftMCP(TTypType& AR_TypeData){ return (ZtCRef<TTypType>*)(&AR_TypeData);}


    /*  template 인수에 ZtCRef 가 있으면, 해당 값을 참조로 인식하고
        그렇지 않으면, 일반적인 복사해서 전달되는 값으로 인식한다.

        ZtCArray.H 같은 자료 구조에서 사용하고 있다.

        -- 2021-04-10 16:15
    */
    template<typename TType>
        class ZtCCheckRef /*###############################################*/
    {
    public :
        typedef TType TypeData;
        typedef TType TypeRaw ;
    private:
        TypeData mr_Data;
    public :
        ZtCCheckRef(TypeData AR_TypeData) : mr_Data(AR_TypeData){}
    public :
        TypeData GetData(){return mr_Data;}
    public :
        static TypeData PassData(TypeData AO_Data){return AO_Data;}
    };/*
    template<typename TType>
        class ZtCCheckRef #################################################*/


    /*  ZtCRef 전문화 */
    template<typename TType>
        class ZtCCheckRef< ZtCRef<TType> > /*##############################*/
    {
    public :
        typedef TType&        TypeData;
        typedef TType         TypeRaw ;
        typedef ZtCRef<TType> ZCRef   ;
    private:
        TypeData mr_Data;
    public :
        ZtCCheckRef(TypeData AR_TypeData) : mr_Data(AR_TypeData){}
    public :
        TypeData GetData(){return mr_Data;}
    public :
        static TypeData PassData(TypeData AO_Data){return AO_Data;}
        static TypeData PassData(ZCRef&   AO_Data){return AO_Data.GetData();}
    };/*
    template<typename TType>
        class ZtCCheckRef< ZtCRef<TType> > ################################*/


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

    ■  ZtCRef* 전문화

        아래 함수

            template<typename TTypType> inline
                ZtCRef<TTypType>* ZftMakeCPtr(TTypType& AR_TypeData)
                    { return (ZtCRef<TTypType>*)(&AR_TypeData); }

        를 통해, 생성된 포인터에 대해서, 정적 멤버 PassData() 로
        TypeRaw* 로 강제변환하고 있다. 그래서 ZtCRef<TTypType> 객
        체의 생성없이 TypeRaw 를 참조로 다룰려고 하는 것이다.

        -- 2025-08-07 17:19

    ///////////////////////////////////////////////////////////////////////*/
    template<typename TType>
        class ZtCCheckRef< ZtCRef<TType>* > /*#############################*/
    {
    public :
        typedef TType&        TypeData;
        typedef TType         TypeRaw ;
        typedef ZtCRef<TType> ZCRef   ;
    private:
        TypeData mr_Data;
    public :
        ZtCCheckRef(TypeData AR_TypeData) : mr_Data(AR_TypeData){}
    public :
        TypeData GetData(){return mr_Data;}
    public :
        static TypeData PassData(TypeData AO_Data){return AO_Data;}
        static TypeData PassData(ZCRef&   AO_Data){return AO_Data.GetData();}
        static TypeData PassData(ZCRef*   AP_CRef)
            { return *reinterpret_cast<TypeRaw*>(AP_CRef); }
    };/*
    template<typename TType>
        class ZtCCheckRef< ZtCRef<TType>* > ###############################*/


    template<typename TType> class ZtCCheckConstRef
    {
        public: enum {ZEConstRef = 0};
    };/*
    template<typename TType> class ZtCCheckConstRef*/

    template<typename TType> class ZtCCheckConstRef<const TType&>
    {
        public: enum {ZEConstRef = 1};
    };/*
    template<typename TType> class ZtCCheckConstRef<const TType&>*/


    namespace ZNsType
    {

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

        ■  (주로 클래스) 템플릿에는 typename 인수를 10 개 이상 요구하는 복잡한 템플릿이 있는데 이런
            템플릿의 typename 을 미리 예를 들어 명시함으로서 그 템플릿의 typename 을 지정하기 쉽도록
            가이드라인을 제시하는 역할의 어떤 클래스나 데이타 타입이 올 수 있는데 이런 자료형이 이
            이름공간에 온다. 어떤 데이타타입을 주로 typedef 하는 클래스라면 접두어 ZtCType 를 붙인다.

        ■  ZtCTypeCRTP<> 는 어떤 클래스 템플릿이 CRTP(CURIOUSLY RECURRING TEMPLATE PATTERN) 를 사용
            하는지 아닌지를 알려준다. ZtCTypeCRTP<> 을 설계하지 않는다면, 같은 기능을 하기 위해, 클
            래스를 2 개(CRTP 를 사용하는 클래스와, 그렇지 않은 클래스)를 만들어야 했을 것이다.

            -- 2010-03-12 20:00:00

            class ZtCTypeCRTP  는 상속 클래스만을 표시하고,
            class ZtCTypeCRTP2 는 상속 클래스와 기반 클래스 모두를 표시한다.

            어쩌면 모든 상속 클래스는 내부적으로, ZtCTypeCRTP 클래스를 갖는 원칙을 세우는 것도 좋겠
            다. 그래서 상속 클래스가 CDerive0 라면, 기반 클래스에 접근하고 싶을 때,

                CDerive0::ZtCTypeCRTP::TypeData

            형식으로 일관성있게 접근하도록 하는 것이다. 그러자면 다중 상속의 경우에 문제가 있겠네.

            -- 2021-03-25 16:01

        ■  또한 이 이름 공간에 있는 클래스는 TypeData 라는 자료형을 갖는 것으로 하자.

            -- 2011-10-18 21:51:00

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



        /*#########################################################################################

        ■  2번 template parameter 가 bool TTypebUseCRTP 인데, 만약 TTypeChild 가 유효한 자료형이라
            면, TTypebUseCRTP 이 true 인 것이 맞겠으나, DEBUG 등의 특수한 용도로 TTypebUseCRTP 을
            false 로 설정할 수 있게 한 것이다.

            -- 2025-09-28 08:41

        #########################################################################################*/

        template<   typename TTypeChild=ZCEmpty, bool TTypebUseCRTP =false
                >
        class ZtCTypeCRTP ////////////////////////////////////////////////
        {
        public:
            typedef TTypeChild TypeData;
        public:
            enum{ZEUseCRTP=(ZTypIntE)TTypebUseCRTP};
        public:
        };/*
        template<   typename TTypeChild=ZCEmpty, bool TTypebUseCRTP =false
                >
        class ZtCTypeCRTP //////////////////////////////////////////////*/



    #if(_CODE_OLD_)

        /*#########################################################################################

        ■  ZtCTypeCRTP2 이 필요한 곳에 ZtCTypeNowCRTP 을 사용하자. -- 2025-09-28 09:25

            ZtCBaseList 에서 ZtCTypeCRTP 와 ZtCTypeNowCRTP 을 사용하고 있다.

        #########################################################################################*/

        template<   typename TTypeChild   = ZCEmpty , ////////////////////
                    typename TTypeBase    = ZCEmpty ,
                    bool     TTypebUseCRTP= false
                >
        class ZtCTypeCRTP2 ///////////////////////////////////////////////
        {
        public:
            typedef TTypeChild TypeData;
            typedef TTypeBase  TypeBase;
        public:
            enum{ZEUseCRTP=(ZTypIntE)TTypebUseCRTP};
        public:
        }; /*
        template<   typename TTypeChild   = ZCEmpty , ////////////////////
                    typename TTypeBase    = ZCEmpty ,
                    bool     TTypebUseCRTP= false
                >
        class ZtCTypeCRTP2 /////////////////////////////////////////////*/

    #endif //_CODE_OLD_


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

        ■  class ZtCTypeCRTP2<> 이 왜 필요한지, 그리고 사용례는 예전 파일 CWorkPool.H 의
            '주석-CCtrlAllocWork::CRTP2'를 참고한다.

            -- 2012-09-20 09:46:00

        ■  해당 코드는 대충 이렇다. -- 2025-09-28 02:41

            template<   typename TWork      ,
                        typename TWorkExec  , // 작업(TWork)에 대하여 어떤 처리를 하는 클래스
                        typename TWorkArg  =const TWork&         ,
                        typename TBarrier  =std::CBarrier_T<>    , // 작업 쓰레드의 시작 및 종료 대기 barrier
                        typename TSyncWait =std::CThreadSemaphore,
                        typename TSyncExec =std::CDefLockEasy    ,
                        typename TWorkList =NsCPP::CObjList<TWork,TWorkArg>  , // 작업 큐 컨테이너
                        typename TTypeBase =NsIFace::CAllocWork_BASE_T<TWork>,
                        typename TFetchWork=TWorkList                        , // 작업 큐에서 작업을 가져오는 컨테이너.
                        typename TTypeCRTP =std::NsType::CTypeCRTP2_T< NsIFace::ICtrlAllocWork, NsIFace::ICtrlAllocWork >
                    >
            class CTypeCtrlAllocWork_T //////////////////////////////////////////////////////////////////////////////////
            {
            public:

                class CThread   ;
                class CBaseClass;

                typedef TWork      CWork     ;
                typedef TWorkArg   CWorkArg  ;
                typedef TWorkExec  CWorkExec ;
                typedef TBarrier   CBarrier  ;
                typedef TSyncWait  CSyncWait ;
                typedef TSyncExec  CSyncExec ;
                typedef TWorkList  CWorkList ;
                typedef TFetchWork CFetchWork;
                typedef TTypeCRTP  CTypeCRTP ;

                typedef typename TWorkList::TypeAlloc CAlloc     ;
                typedef std::CAutoKey_T<CSyncExec>    CAutoKey   ;
                typedef NsCPP::CObjList
                    <
                        CThread       ,
                        const CThread&,
                        CAlloc
                    > CThreadList;
                typedef typename CThreadList::CLink   CThreadLink;


                #define _CAllocWork_BASE_ std::CAllocWork_T<  \
                                CWork         , \
                                CWorkArg      , \
                                CSyncWait     , \
                                CSyncExec     , \
                                CWorkList     , \
                                CThread       , \
                                CBaseClass    , \
                                std::NsType::CTypeCRTP_T<CAllocWork, true> >

                class CAllocWork : public _CAllocWork_BASE_
                {
                    // some code
                }
            };


            template<typename TTypeCtrlAllocWork>
            class CCtrlAllocWork_T : protected TTypeCtrlAllocWork::CSyncKey  ,
                                     protected TTypeCtrlAllocWork::CAllocWork,
                                     protected TTypeCtrlAllocWork::CTypeCRTP::TypeBase
            {
            public   :
                enum{EMaxThreadCnt=1}; typedef NsEnum::EThreadPoolStep EPoolStep;
            public   :
                typedef typename TTypeCtrlAllocWork::CWork       CWork      ;
                typedef typename TTypeCtrlAllocWork::CWorkArg    CWorkArg   ;
                typedef typename TTypeCtrlAllocWork::CWorkExec   CWorkExec  ;
                typedef typename TTypeCtrlAllocWork::CThread     CThread    ;
                typedef typename TTypeCtrlAllocWork::CSyncKey    CSyncKey   ;
                typedef typename TTypeCtrlAllocWork::CSyncExec   CSyncExec  ;
                typedef typename TTypeCtrlAllocWork::CAutoKey    CAutoKey   ;
                typedef typename TTypeCtrlAllocWork::CAllocWork  CAllocWork ;
                typedef typename TTypeCtrlAllocWork::CBaseClass  CBaseClass ;
                typedef typename TTypeCtrlAllocWork::CWorkList   CWorkList  ;
                typedef typename TTypeCtrlAllocWork::CFetchWork  CFetchWork ;
                typedef typename TTypeCtrlAllocWork::CThreadList CThreadList;
                typedef typename TTypeCtrlAllocWork::CThreadLink CThreadLink;
                typedef typename TTypeCtrlAllocWork::CTypeCRTP   CTypeCRTP  ;


                // some code


                void SetCloseMark(CWork& ARR_CWork)
                {
                    if(CTypeCRTP::EUseCRTP>0)
                    {
                        typedef typename CTypeCRTP::TypeData CCtrlAllocWorkEx;

                    #if(_CODE_NEW_)
                        static_cast<CCtrlAllocWorkEx&>(*this). // 코드-CCtrlAllocWork::CRTP2
                            SetCloseMarkInChild(RR(ARR_CWork)); return;
                    #else
                        ((CCtrlAllocWorkEx&)(*this)).          // 코드-CCtrlAllocWork::CRTP
                            SetCloseMarkInChild(RR(ARR_CWork)); return;
                    #endif

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

                        ■  주석-CCtrlAllocWork::CRTP2

                            이전에는 상속 클래스의 SetCloseMarkInChild() 을 사용하기 위해 위의 '코드-CCtrlAllocWork::CRTP'
                            를 사용하였으나 약간의 안전성 상승을 위해, std::NsType::CTypeCRTP2_T<> 을 긴급히 정의하고, NsT
                            ype::CTypeCtrlAllocWork_T<> 의 템플릿 인수에 typename TTypeCRTP 를 추가한 다음, '코드-CCtrlAll
                            ocWork::CRTP2' 를 사용하게 되었다. 그래서 class CCtrlAllocWork_T<> 이

                                TTypeCtrlAllocWork::CTypeCRTP::TypeBase

                            을 상속하고 있다. 이 TypeBase 는 SetCloseMarkInChild(CWork&) 함수를 가져야 한다.

                            -- 2012-09-20 09:43:00

                        ■  NsType::CTypeCRTP2_T<> 는 NsType::CTypeCRTP_T<> 에서 TypeBase 가 추가된 것이다.

                            -- 2012-09-20 09:57:00

                        //////////////////////////////////////////////////////////////////////////////////////////////////
                    }

                    CWorkExec::SetCloseMark(RR(ARR_CWork));
                }
              //void SetCloseMark(CWork& ARR_CWork)


              // some code


            }


            즉 아래 코드로

                typedef typename CTypeCRTP::TypeData CCtrlAllocWorkEx;

            CCtrlAllocWork_T 의 상속 클래스에 접근하고 있는데, 이것은 좀 이상하다.

            즉 CTypeCRTP::TypeData 은 NsIFace::ICtrlAllocWork 이기 때문이다. 예전
            코드라 그런지 나쁜 냄새가 난다.

            -- 2025-09-28 07-27


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


        /*#########################################################################################

        ■  class ZtCTypeCRTP<> 의 단점은 상속하지 않은 class 형은 알 수 없는데, 이것을 알아내기 위해
        
                class ZtCTypeNowCRTP<>

            을 설계한다. 이 클래스의 사용예는 예전 파일 CCtrlAsyncSock.H 에 있었다.

                -- 현재(2025-08-02 22:37) CCtrlAsyncSock.H 는 없다.

            아래 코드에서 TAsyncServ 의 상속 클래스가

                없다면, CMainServ  는 TAsyncServ 과 같고,
                있다면, CMainServ0 가 상속 클래스

            가 된다.

                typedef typename TAsyncServ::ZtCTypeCRTP ZtCTypeCRTP ;
                typedef typename ZtCTypeCRTP ::TypeData  CMainServ0  ;

                typedef std::ZNsType::ZtCTypeNowCRTP<
                    TAsyncServ, CMainServ0>::TypeData  CMainServ ;

                CMainServ& VR_CMainServ=
                    static_cast<CMainServ&>(ArCAsyncServ);

            ZtCTypeNowCRTP<> 이 없었을 때에는 TAsyncServ 이 상속 클래스를 갖지 않은 경우, CMainServ0 이 ZCEmpty 가 되어서,
            컴파일 에러를 피하기가 매우 복잡한 경우가 있었다. 지금은 상속 클래스가 없다면 그냥 자기 자신의 인터페이스를
            사용하니까 컴파일 에러가 전혀 없다.

            정말 멋진 기교가 아닌가. C++ 의 향기에 잠시 취해 보자. -- 2013-06-10 00:33:00

        ■  ZtCTypeNowCRTP 의 template parameter 에 bool TTypebUseCRTP 추가. -- 2025-09-28 15:55

            TTypeChild 가 ZCEmpty 이거나 TTypebUseCRTP 이 false 이면, 아래가 된다.

                public: enum{ZEUseCRTP=0};
                public: typedef TTypeNow TypeData;
                public: typedef TTypeNow TypeBase;

            그리고 TTypeChild 가 ZCEmpty 이고 TTypebUseCRTP 이 false 인 경우도 전문화해주어야 한다.

                class ZtCTypeNowCRTP<TTypeNow, ZCEmpty, false>

        ■  3번 template parameter 가 bool TTypebUseCRTP 인데, 만약 TTypeChild 가 유효한 자료형이라
            면, TTypebUseCRTP 이 true 인 것이 맞겠으나, DEBUG 등의 특수한 용도로 TTypebUseCRTP 을
            false 로 설정할 수 있게 한 것이다.

            주로 ZtCTypeCRTP 와 같이 사용해, 가상 함수를 사용하지 않고도 상속을 통해 다형성을 구현하
            거나 기능 확장을 하고 싶을 때 사용한다. 보통 CRTP 는 상속을 전제로 하는 상황에서 주로 쓰
            이지만, ZtCTypeNowCRTP 는 꼭 상속을 강제하지 않는다.

            사용예는 ZtCBaseList 에 있다.

            -- 2025-09-28 16:13

        #########################################################################################*/

        template
            <typename TTypeNow, typename TTypeChild, bool TTypebUseCRTP>
        class ZtCTypeNowCRTP
            {
                public: enum{ZEUseCRTP=(ZTypIntE)TTypebUseCRTP};
            /*++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/
                public: typedef TTypeChild TypeData;
                public: typedef TTypeNow   TypeBase;
            };

        template
            <typename TTypeNow, typename TTypeChild>
        class ZtCTypeNowCRTP<TTypeNow, TTypeChild, false /*++*/ >
            {
                public: enum{ZEUseCRTP=0};
                public: typedef TTypeNow TypeData;
                public: typedef TTypeNow TypeBase;
            };

        template
            <typename TTypeNow, bool TTypebUseCRTP>
        class ZtCTypeNowCRTP<TTypeNow, ZCEmpty   , TTypebUseCRTP>
            {
                public: enum{ZEUseCRTP=0};
                public: typedef TTypeNow TypeData;
                public: typedef TTypeNow TypeBase;
            };

        template
            <typename TTypeNow>
        class ZtCTypeNowCRTP<TTypeNow, ZCEmpty   , false /*++*/ >
            {
                public: enum{ZEUseCRTP=0};
                public: typedef TTypeNow TypeData;
                public: typedef TTypeNow TypeBase;
            };
        /////////////////////////////////////////////////////////



        namespace ZNsTmplParam
        {
            /*//////////////////////////////////////////////////////////////////////////

            ■  이 이름 공간에는 어떤 템플릿의 인수가 많고, 이 인수가 몇 개의 인수가 기본
                값을 갖는 경우, 끝 부분에 있는 기본값 정의 인수에 명시적인 자료형을 지정
                해야 할 때, 그 이전의 기본 인수에 대해서도 일일이 지정을 해야 하는데, 이
                런 불편을 일부 덜기 위해서 기본값 정의 순서가 다른 template 을 설계한다.
                여기에 놓이는 클래스는 CParam~ 으로 시작하자.

            ■  ZNsTmplParam 이름공간은 꼭 ZNsType 에만 있을 필요는 없다. 그보다 더 적절한
                장소가 있다면 그 곳에 선언하자.

            //////////////////////////////////////////////////////////////////////////*/
        }/*
        namespace ZNsTmplParam*/

    }/*
    namespace ZNsType*/



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

    ■  가끔 템플릿으로 클래스 설계를 하다보면 템플릿의 parameter 가
        포인터나 참조일 경우, 무엇의 포인터나 참조형인지 알고 싶을 때
        가 있다. 이런 경우에 ZtCTypeData<> 를 사용한다.

        cf)

        cout<<typeid(std::ZtCTypeData<ZTypIntI >::TypeData).name()<<endl;
        cout<<typeid(std::ZtCTypeData<ZTypIntI*>::TypeData).name()<<endl;
        cout<<typeid(std::ZtCTypeData<ZTypIntI&>::TypeData).name()<<endl;

        -- 2010-01-15 00:11:00

    ■  ZtCTypeData<>::GetObjRef(~) 는 주로 참조나 포인터 자료형에 대
        해, 무슨 자료형에 대한 참조 혹은 포인터인지 판단해서, 가급적
        참조로 전달하도록 한다. 참조도 아니고 포인터도 아닌 자료형이
        면, 당연히 보통의 복사 생성으로 자료형의 값을 반환한다.

        주로 (멤버) 함수 템플릿에서 사용할 것이다. -- 2025-09-28 22:08

    ■  --

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

    typedef void (*ZfpNone)(void*);  void ZfNone(void* AP_Void=0){};

    template<typename TType> class ZtCTypeData
        { public: typedef TType  TypeData;
            static TType&  GetObjRef(TType& AR_Type){return AR_Type ;}};
    template<typename TType> class ZtCTypeData<TType*>
        { public: typedef TType  TypeData;
            static TType&  GetObjRef(TType* AP_Type){return *AP_Type;}};
    template<typename TType> class ZtCTypeData<TType&>
        { public: typedef TType  TypeData;
            static TType&  GetObjRef(TType& AR_Type){return AR_Type ;}};
    template< /*########*/ > class ZtCTypeData<void* >
        { public: typedef ZfpNone TypeData;
            static ZfpNone GetObjRef(void*  AP_Void){return ZfNone  ;}};

    template<typename TType> class ZtCTypeData< ZtCRef<TType>  >
        { public: typedef TType  TypeData; static TType&
            GetObjRef(ZtCRef<TType>& AR_CRef)
              {return AR_CRef.GetData() /*//////////////*/ ;}
        };
    template<typename TType> class ZtCTypeData< ZtCRef<TType>* >
        { public: typedef TType  TypeData; static TType&
            GetObjRef(ZtCRef<TType>* AP_CRef)
              {return *reinterpret_cast<TypeData*>(AP_CRef);}
        };


    template<typename TType> class ZtCTD
        { public: typedef TType  TypeData;
            static TType&  GetObjRef(TType& AR_Type){return AR_Type ;}
            static TType&  GOR      (TType& AR_Type){return AR_Type ;}};
    template<typename TType> class ZtCTD<TType*>
        { public: typedef TType  TypeData;
            static TType&  GetObjRef(TType* AP_Type){return *AP_Type;}
            static TType&  GOR      (TType* AP_Type){return *AP_Type;}};
    template<typename TType> class ZtCTD<TType&>
        { public: typedef TType  TypeData;
            static TType&  GetObjRef(TType& AR_Type){return AR_Type ;}
            static TType&  GOR      (TType& AR_Type){return AR_Type ;}};
    template< /*########*/ > class ZtCTD<void* >
        { public: typedef ZfpNone TypeData;
            static ZfpNone GetObjRef(void*  AP_Void){return ZfNone  ;}
            static ZfpNone GOR      (void*  AP_Void){return ZfNone  ;}};


    template<typename TType> class ZtCTD< ZtCRef<TType>  >
        { public: typedef TType  TypeData;
            static TType& GetObjRef(ZtCRef<TType>& AR_CRef){return AR_CRef.GetData() ;}
            static TType& GOR      (ZtCRef<TType>& AR_CRef){return AR_CRef.GetData() ;}
        };
    template<typename TType> class ZtCTD< ZtCRef<TType>* >
        { public: typedef TType  TypeData;
            static TType& GetObjRef(ZtCRef<TType>* AP_CRef)
                {return *reinterpret_cast<TypeData*>(AP_CRef);}
            static TType& GOR      (ZtCRef<TType>* AP_CRef)
                {return *reinterpret_cast<TypeData*>(AP_CRef);}
        };



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

    ■  template 인수가 Type11 까지 있음에 주의한다. 그러면 Type10 까지 전문화할 수 있는 것이다.

        -- 2015-02-16 21:20:00

        단, template 인수는 2개부터가 유효하다.

            typedef ZtStTuple<int>      CTupleInt1 는 오류다.
            typedef ZtStTuple<int, int> CTupleInt2 는 정상이다.

        상식적으로도 ZtStTuple<int> 으로 쓸 일은 없다. -- 2021-03-04 16:27

        지금은 template 인수가 Type13 까지 있다. 그러면 Type12 까지 전문화할 수 있는 것이다. -- 2025-09-07 12:55

    ■  이젠 ZtStTuple<int> 형태도 가능하다. ZftMakeTuple() 도 추가. - -2025-09-05 21:01

    ■  RVO(Return Value Optimization) 로 인해 아래가 가능하다. -- 2025-09-06 21:23

        int VariMy=0; ZtStTuple<int&> myt1 = ZftMakeTuple(ZftMCP(VariMy));

    ■  std::tuple<> 용례-1 -- 2025-09-07 12:08

        #include <tuple>
        #include <iostream>

        int main() {
            int nownum=42;

            // Creating a tuple
            std::tuple<int&, std::string, double> myTuple(nownum, "Hello", 3.14);

            // Accessing elements
            std::cout << std::get<0>(myTuple) << "\n"; // Outputs: 42
            std::cout << std::get<1>(myTuple) << "\n"; // Outputs: Hello
            std::cout << std::get<2>(myTuple) << "\n"; // Outputs: 3.14

            // Modifying elements
            std::get<1>(myTuple) = "World";
            std::cout << std::get<1>(myTuple) << "\n"; // Outputs: World

            return 0;
        }

    ■  std::tuple<> 용례-2 -- 2025-09-07 12:09

        #include <tuple>
        #include <iostream>

        std::tuple<int, double, std::string> getValues() {
            return {42, 3.14, "Hello"};
        }

        int main() {
            auto [x, y, z] = getValues(); // Structured binding (C++17)
            std::cout << x << ", " << y << ", " << z << "\n"; // Outputs: 42, 3.14, Hello
            return 0;
        }

    ■  std::tuple<> 용례-3 -- 2025-09-07 12:11

        #include <iostream>
        #include <tuple>
        #include <string>

        int main() {
        // 기본 생성 및 값 할당
        std::tuple<std::string, int, double> tpl;
        std::get<0>(tpl) = "Example";
        std::get<1>(tpl) = 42       ;
        std::get<2>(tpl) = 3.14     ;

        // make_tuple을 사용한 초기화
        auto tpl2 = std::make_tuple("Hello", 100, 1.23);

        // 구조적 바인딩 (C++17 이상)
        auto [str, num, val] = tpl2;

        std::cout << "Tuple 1: " << std::get<0>(tpl) << ", " << std::get<1>(tpl) << ", " << std::get<2>(tpl) << '\n';
        std::cout << "Tuple 2: " << str << ", " << num << ", " << val << '\n';

        return 0;
        }


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

    template<   typename Type1 =void*, typename Type2 =void*,
                typename Type3 =void*, typename Type4 =void*,
                typename Type5 =void*, typename Type6 =void*,
                typename Type7 =void*, typename Type8 =void*,
                typename Type9 =void*, typename Type10=void*,
                typename Type11=void*, typename Type12=void*,
                typename Type13=void*
            >
    struct ZtStTuple //////////////////////////////////////////////////////////////////////////////
    {
        ZtStTuple(){}
    };
    /*###########################################################################################*/


    template<typename Type1> struct ZtStTuple<Type1>
    {
        typedef ZNsMain::ZtCCheckRef<Type1>   CCheckRef1 ;
        typedef typename CCheckRef1::TypeData TypeData1  ;

        TypeData1 _1;

        ZtStTuple<Type1>(){}
        ZtStTuple<Type1>(Type1 _T1) :
            _1(CCheckRef1::PassData(_T1))
        {}
    };
    /*###########################################################################################*/
    template
        < typename Type1, typename Type2 >
    struct ZtStTuple<Type1, Type2>
    {
        typedef ZNsMain::ZtCCheckRef<Type1>   CCheckRef1 ;
        typedef ZNsMain::ZtCCheckRef<Type2>   CCheckRef2 ;

        typedef typename CCheckRef1::TypeData TypeData1  ;
        typedef typename CCheckRef2::TypeData TypeData2  ;

        TypeData1 _1;  TypeData2 _2;

        ZtStTuple<Type1, Type2>(){}
        ZtStTuple<Type1, Type2>(Type1 _T1, Type2 _T2) :
            _1(CCheckRef1::PassData(_T1)),
            _2(CCheckRef2::PassData(_T2))
        {}
    };
    /*###########################################################################################*/
    template
        < typename Type1, typename Type2, typename Type3 >
    struct ZtStTuple<Type1, Type2, Type3>
    {
        typedef ZNsMain::ZtCCheckRef<Type1>   CCheckRef1 ;
        typedef ZNsMain::ZtCCheckRef<Type2>   CCheckRef2 ;
        typedef ZNsMain::ZtCCheckRef<Type3>   CCheckRef3 ;

        typedef typename CCheckRef1::TypeData TypeData1  ;
        typedef typename CCheckRef2::TypeData TypeData2  ;
        typedef typename CCheckRef3::TypeData TypeData3  ;

        TypeData1 _1;  TypeData2 _2;  TypeData3 _3;

        ZtStTuple<Type1, Type2, Type3>(){}
        ZtStTuple<Type1, Type2, Type3>
            (Type1 _T1, Type2 _T2, Type3 _T3) :
                _1(CCheckRef1::PassData(_T1)),
                _2(CCheckRef2::PassData(_T2)),
                _3(CCheckRef3::PassData(_T3))
        {}
    };
    /*###########################################################################################*/
    template
        < typename Type1, typename Type2, typename Type3, typename Type4 >
    struct ZtStTuple<Type1, Type2, Type3, Type4>
    {
        typedef ZNsMain::ZtCCheckRef<Type1>   CCheckRef1 ;
        typedef ZNsMain::ZtCCheckRef<Type2>   CCheckRef2 ;
        typedef ZNsMain::ZtCCheckRef<Type3>   CCheckRef3 ;
        typedef ZNsMain::ZtCCheckRef<Type4>   CCheckRef4 ;

        typedef typename CCheckRef1::TypeData TypeData1  ;
        typedef typename CCheckRef2::TypeData TypeData2  ;
        typedef typename CCheckRef3::TypeData TypeData3  ;
        typedef typename CCheckRef4::TypeData TypeData4  ;

        TypeData1 _1;  TypeData2 _2;  TypeData3 _3;  TypeData4 _4;

        ZtStTuple<Type1, Type2, Type3, Type4>(){}
        ZtStTuple<Type1, Type2, Type3, Type4>
            (Type1 _T1, Type2 _T2, Type3 _T3, Type4 _T4) :
                _1(CCheckRef1::PassData(_T1))
              , _2(CCheckRef2::PassData(_T2))
              , _3(CCheckRef3::PassData(_T3))
              , _4(CCheckRef4::PassData(_T4))
        {}
    };
    /*###########################################################################################*/
    template
        <   typename Type1, typename Type2, typename Type3,
            typename Type4, typename Type5
        >
    struct ZtStTuple<Type1, Type2, Type3, Type4, Type5>
    {
        typedef ZNsMain::ZtCCheckRef<Type1>   CCheckRef1 ;
        typedef ZNsMain::ZtCCheckRef<Type2>   CCheckRef2 ;
        typedef ZNsMain::ZtCCheckRef<Type3>   CCheckRef3 ;
        typedef ZNsMain::ZtCCheckRef<Type4>   CCheckRef4 ;
        typedef ZNsMain::ZtCCheckRef<Type5>   CCheckRef5 ;

        typedef typename CCheckRef1::TypeData TypeData1  ;
        typedef typename CCheckRef2::TypeData TypeData2  ;
        typedef typename CCheckRef3::TypeData TypeData3  ;
        typedef typename CCheckRef4::TypeData TypeData4  ;
        typedef typename CCheckRef5::TypeData TypeData5  ;

        TypeData1 _1;  TypeData2 _2;  TypeData3 _3;  TypeData4 _4;  TypeData5 _5;

        ZtStTuple<Type1, Type2, Type3, Type4, Type5>(){}
        ZtStTuple<Type1, Type2, Type3, Type4, Type5>
            (Type1 _T1, Type2 _T2, Type3 _T3, Type4 _T4, Type5 _T5) :
                _1(CCheckRef1::PassData(_T1))
              , _2(CCheckRef2::PassData(_T2))
              , _3(CCheckRef3::PassData(_T3))
              , _4(CCheckRef4::PassData(_T4))
              , _5(CCheckRef5::PassData(_T5))
        {}
    };
    /*###########################################################################################*/
    template
        <   typename Type1, typename Type2, typename Type3,
            typename Type4, typename Type5, typename Type6
        >
    struct ZtStTuple<Type1, Type2, Type3, Type4, Type5, Type6>
    {
        typedef ZNsMain::ZtCCheckRef<Type1>   CCheckRef1 ;
        typedef ZNsMain::ZtCCheckRef<Type2>   CCheckRef2 ;
        typedef ZNsMain::ZtCCheckRef<Type3>   CCheckRef3 ;
        typedef ZNsMain::ZtCCheckRef<Type4>   CCheckRef4 ;
        typedef ZNsMain::ZtCCheckRef<Type5>   CCheckRef5 ;
        typedef ZNsMain::ZtCCheckRef<Type6>   CCheckRef6 ;

        typedef typename CCheckRef1::TypeData TypeData1  ;
        typedef typename CCheckRef2::TypeData TypeData2  ;
        typedef typename CCheckRef3::TypeData TypeData3  ;
        typedef typename CCheckRef4::TypeData TypeData4  ;
        typedef typename CCheckRef5::TypeData TypeData5  ;
        typedef typename CCheckRef6::TypeData TypeData6  ;

        TypeData1 _1;  TypeData2 _2;  TypeData3 _3;
        TypeData4 _4;  TypeData5 _5;  TypeData6 _6;

        ZtStTuple<Type1, Type2, Type3, Type4, Type5, Type6>(){}
        ZtStTuple<Type1, Type2, Type3, Type4, Type5, Type6>
            (
                Type1 _T1, Type2 _T2, Type3 _T3, Type4 _T4, Type5 _T5, Type6 _T6
            ) :
                _1(CCheckRef1::PassData(_T1))
              , _2(CCheckRef2::PassData(_T2))
              , _3(CCheckRef3::PassData(_T3))
              , _4(CCheckRef4::PassData(_T4))
              , _5(CCheckRef5::PassData(_T5))
              , _6(CCheckRef6::PassData(_T6))
        {}
    };
    /*###########################################################################################*/
    template
        <   typename Type1, typename Type2, typename Type3,
            typename Type4, typename Type5, typename Type6, typename Type7
        >
    struct ZtStTuple<Type1, Type2, Type3, Type4, Type5, Type6, Type7>
    {
        typedef ZNsMain::ZtCCheckRef<Type1>   CCheckRef1 ;
        typedef ZNsMain::ZtCCheckRef<Type2>   CCheckRef2 ;
        typedef ZNsMain::ZtCCheckRef<Type3>   CCheckRef3 ;
        typedef ZNsMain::ZtCCheckRef<Type4>   CCheckRef4 ;
        typedef ZNsMain::ZtCCheckRef<Type5>   CCheckRef5 ;
        typedef ZNsMain::ZtCCheckRef<Type6>   CCheckRef6 ;
        typedef ZNsMain::ZtCCheckRef<Type7>   CCheckRef7 ;

        typedef typename CCheckRef1::TypeData TypeData1  ;
        typedef typename CCheckRef2::TypeData TypeData2  ;
        typedef typename CCheckRef3::TypeData TypeData3  ;
        typedef typename CCheckRef4::TypeData TypeData4  ;
        typedef typename CCheckRef5::TypeData TypeData5  ;
        typedef typename CCheckRef6::TypeData TypeData6  ;
        typedef typename CCheckRef7::TypeData TypeData7  ;

        TypeData1 _1;  TypeData2 _2;  TypeData3 _3; TypeData4 _4;
        TypeData5 _5;  TypeData6 _6;  TypeData7 _7;

        ZtStTuple<Type1, Type2, Type3, Type4, Type5, Type6, Type7>(){}
        ZtStTuple<Type1, Type2, Type3, Type4, Type5, Type6, Type7>
            (
                Type1 _T1, Type2 _T2, Type3 _T3, Type4 _T4,
                Type5 _T5, Type6 _T6, Type7 _T7
            ) :
                _1(CCheckRef1::PassData(_T1))
              , _2(CCheckRef2::PassData(_T2))
              , _3(CCheckRef3::PassData(_T3))
              , _4(CCheckRef4::PassData(_T4))
              , _5(CCheckRef5::PassData(_T5))
              , _6(CCheckRef6::PassData(_T6))
              , _7(CCheckRef7::PassData(_T7))
        {}
    };
    /*###########################################################################################*/
    template
        <   typename Type1, typename Type2, typename Type3,
            typename Type4, typename Type5, typename Type6,
            typename Type7, typename Type8
        >
    struct ZtStTuple<Type1, Type2, Type3, Type4, Type5, Type6, Type7, Type8>
    {
        typedef ZNsMain::ZtCCheckRef<Type1>   CCheckRef1 ;
        typedef ZNsMain::ZtCCheckRef<Type2>   CCheckRef2 ;
        typedef ZNsMain::ZtCCheckRef<Type3>   CCheckRef3 ;
        typedef ZNsMain::ZtCCheckRef<Type4>   CCheckRef4 ;
        typedef ZNsMain::ZtCCheckRef<Type5>   CCheckRef5 ;
        typedef ZNsMain::ZtCCheckRef<Type6>   CCheckRef6 ;
        typedef ZNsMain::ZtCCheckRef<Type7>   CCheckRef7 ;
        typedef ZNsMain::ZtCCheckRef<Type8>   CCheckRef8 ;

        typedef typename CCheckRef1::TypeData TypeData1  ;
        typedef typename CCheckRef2::TypeData TypeData2  ;
        typedef typename CCheckRef3::TypeData TypeData3  ;
        typedef typename CCheckRef4::TypeData TypeData4  ;
        typedef typename CCheckRef5::TypeData TypeData5  ;
        typedef typename CCheckRef6::TypeData TypeData6  ;
        typedef typename CCheckRef7::TypeData TypeData7  ;
        typedef typename CCheckRef8::TypeData TypeData8  ;

        TypeData1 _1;  TypeData2 _2;  TypeData3 _3; TypeData4 _4;
        TypeData5 _5;  TypeData6 _6;  TypeData7 _7; TypeData8 _8;

        ZtStTuple<Type1, Type2, Type3, Type4, Type5, Type6, Type7, Type8>(){}
        ZtStTuple<Type1, Type2, Type3, Type4, Type5, Type6, Type7, Type8>
            (
                Type1 _T1, Type2 _T2, Type3 _T3, Type4 _T4,
                Type5 _T5, Type6 _T6, Type7 _T7, Type8 _T8
            ) :
                _1(CCheckRef1::PassData(_T1))
              , _2(CCheckRef2::PassData(_T2))
              , _3(CCheckRef3::PassData(_T3))
              , _4(CCheckRef4::PassData(_T4))
              , _5(CCheckRef5::PassData(_T5))
              , _6(CCheckRef6::PassData(_T6))
              , _7(CCheckRef7::PassData(_T7))
              , _8(CCheckRef8::PassData(_T8))
        {}
    };
    /*###########################################################################################*/
    template
        <   typename Type1, typename Type2, typename Type3,
            typename Type4, typename Type5, typename Type6,
            typename Type7, typename Type8, typename Type9
        >
    struct ZtStTuple
        <Type1, Type2, Type3, Type4, Type5, Type6, Type7, Type8, Type9>
    {
        typedef ZNsMain::ZtCCheckRef<Type1>   CCheckRef1 ;
        typedef ZNsMain::ZtCCheckRef<Type2>   CCheckRef2 ;
        typedef ZNsMain::ZtCCheckRef<Type3>   CCheckRef3 ;
        typedef ZNsMain::ZtCCheckRef<Type4>   CCheckRef4 ;
        typedef ZNsMain::ZtCCheckRef<Type5>   CCheckRef5 ;
        typedef ZNsMain::ZtCCheckRef<Type6>   CCheckRef6 ;
        typedef ZNsMain::ZtCCheckRef<Type7>   CCheckRef7 ;
        typedef ZNsMain::ZtCCheckRef<Type8>   CCheckRef8 ;
        typedef ZNsMain::ZtCCheckRef<Type9>   CCheckRef9 ;

        typedef typename CCheckRef1::TypeData TypeData1  ;
        typedef typename CCheckRef2::TypeData TypeData2  ;
        typedef typename CCheckRef3::TypeData TypeData3  ;
        typedef typename CCheckRef4::TypeData TypeData4  ;
        typedef typename CCheckRef5::TypeData TypeData5  ;
        typedef typename CCheckRef6::TypeData TypeData6  ;
        typedef typename CCheckRef7::TypeData TypeData7  ;
        typedef typename CCheckRef8::TypeData TypeData8  ;
        typedef typename CCheckRef9::TypeData TypeData9  ;

        TypeData1 _1;  TypeData2 _2;  TypeData3 _3; TypeData4 _4;
        TypeData5 _5;  TypeData6 _6;  TypeData7 _7; TypeData8 _8; TypeData9 _9;

        ZtStTuple<Type1, Type2, Type3, Type4, Type5, Type6, Type7, Type8, Type9>(){}
        ZtStTuple<Type1, Type2, Type3, Type4, Type5, Type6, Type7, Type8, Type9>
            (
                Type1 _T1, Type2 _T2, Type3 _T3, Type4 _T4,
                Type5 _T5, Type6 _T6, Type7 _T7, Type8 _T8, Type9 _T9
            ) :
                _1(CCheckRef1::PassData(_T1))
              , _2(CCheckRef2::PassData(_T2))
              , _3(CCheckRef3::PassData(_T3))
              , _4(CCheckRef4::PassData(_T4))
              , _5(CCheckRef5::PassData(_T5))
              , _6(CCheckRef6::PassData(_T6))
              , _7(CCheckRef7::PassData(_T7))
              , _8(CCheckRef8::PassData(_T8))
              , _9(CCheckRef9::PassData(_T9))
        {}
    };
    /*###########################################################################################*/
    template
        <   typename Type1, typename Type2, typename Type3,
            typename Type4, typename Type5, typename Type6,
            typename Type7, typename Type8, typename Type9, typename Type10
        >
    struct ZtStTuple
        <
            Type1, Type2, Type3, Type4, Type5,
            Type6, Type7, Type8, Type9, Type10
        >
    {
        typedef ZNsMain::ZtCCheckRef<Type1 >   CCheckRef1 ;
        typedef ZNsMain::ZtCCheckRef<Type2 >   CCheckRef2 ;
        typedef ZNsMain::ZtCCheckRef<Type3 >   CCheckRef3 ;
        typedef ZNsMain::ZtCCheckRef<Type4 >   CCheckRef4 ;
        typedef ZNsMain::ZtCCheckRef<Type5 >   CCheckRef5 ;
        typedef ZNsMain::ZtCCheckRef<Type6 >   CCheckRef6 ;
        typedef ZNsMain::ZtCCheckRef<Type7 >   CCheckRef7 ;
        typedef ZNsMain::ZtCCheckRef<Type8 >   CCheckRef8 ;
        typedef ZNsMain::ZtCCheckRef<Type9 >   CCheckRef9 ;
        typedef ZNsMain::ZtCCheckRef<Type10>   CCheckRef10;

        typedef typename CCheckRef1 ::TypeData TypeData1  ;
        typedef typename CCheckRef2 ::TypeData TypeData2  ;
        typedef typename CCheckRef3 ::TypeData TypeData3  ;
        typedef typename CCheckRef4 ::TypeData TypeData4  ;
        typedef typename CCheckRef5 ::TypeData TypeData5  ;
        typedef typename CCheckRef6 ::TypeData TypeData6  ;
        typedef typename CCheckRef7 ::TypeData TypeData7  ;
        typedef typename CCheckRef8 ::TypeData TypeData8  ;
        typedef typename CCheckRef9 ::TypeData TypeData9  ;
        typedef typename CCheckRef10::TypeData TypeData10 ;

        TypeData1 _1 ;  TypeData2  _2 ;  TypeData3 _3 ; TypeData4 _4 ;
        TypeData5 _5 ;  TypeData6  _6 ;  TypeData7 _7 ; TypeData8 _8 ;
        TypeData9 _9 ;  TypeData10 _10;

        ZtStTuple<Type1, Type2, Type3, Type4, Type5, Type6, Type7, Type8, Type9, Type10>(){}
        ZtStTuple<Type1, Type2, Type3, Type4, Type5, Type6, Type7, Type8, Type9, Type10>
            (
                Type1 _T1, Type2  _T2 , Type3 _T3, Type4 _T4,
                Type5 _T5, Type6  _T6 , Type7 _T7, Type8 _T8,
                Type9 _T9, Type10 _T10
            ) :
                _1 (CCheckRef1 ::PassData(_T1 ))
              , _2 (CCheckRef2 ::PassData(_T2 ))
              , _3 (CCheckRef3 ::PassData(_T3 ))
              , _4 (CCheckRef4 ::PassData(_T4 ))
              , _5 (CCheckRef5 ::PassData(_T5 ))
              , _6 (CCheckRef6 ::PassData(_T6 ))
              , _7 (CCheckRef7 ::PassData(_T7 ))
              , _8 (CCheckRef8 ::PassData(_T8 ))
              , _9 (CCheckRef9 ::PassData(_T9 ))
              , _10(CCheckRef10::PassData(_T10))
        {}
    };
    /*###########################################################################################*/
    template
        <   typename Type1 , typename Type2 , typename Type3,
            typename Type4 , typename Type5 , typename Type6,
            typename Type7 , typename Type8 , typename Type9,
            typename Type10, typename Type11
        >
    struct ZtStTuple
        <
            Type1, Type2, Type3, Type4 , Type5, Type6,
            Type7, Type8, Type9, Type10, Type11
        >
    {
        typedef ZNsMain::ZtCCheckRef<Type1 >   CCheckRef1 ;
        typedef ZNsMain::ZtCCheckRef<Type2 >   CCheckRef2 ;
        typedef ZNsMain::ZtCCheckRef<Type3 >   CCheckRef3 ;
        typedef ZNsMain::ZtCCheckRef<Type4 >   CCheckRef4 ;
        typedef ZNsMain::ZtCCheckRef<Type5 >   CCheckRef5 ;
        typedef ZNsMain::ZtCCheckRef<Type6 >   CCheckRef6 ;
        typedef ZNsMain::ZtCCheckRef<Type7 >   CCheckRef7 ;
        typedef ZNsMain::ZtCCheckRef<Type8 >   CCheckRef8 ;
        typedef ZNsMain::ZtCCheckRef<Type9 >   CCheckRef9 ;
        typedef ZNsMain::ZtCCheckRef<Type10>   CCheckRef10;
        typedef ZNsMain::ZtCCheckRef<Type11>   CCheckRef11;

        typedef typename CCheckRef1 ::TypeData TypeData1  ;
        typedef typename CCheckRef2 ::TypeData TypeData2  ;
        typedef typename CCheckRef3 ::TypeData TypeData3  ;
        typedef typename CCheckRef4 ::TypeData TypeData4  ;
        typedef typename CCheckRef5 ::TypeData TypeData5  ;
        typedef typename CCheckRef6 ::TypeData TypeData6  ;
        typedef typename CCheckRef7 ::TypeData TypeData7  ;
        typedef typename CCheckRef8 ::TypeData TypeData8  ;
        typedef typename CCheckRef9 ::TypeData TypeData9  ;
        typedef typename CCheckRef10::TypeData TypeData10 ;
        typedef typename CCheckRef11::TypeData TypeData11 ;

        TypeData1 _1 ;  TypeData2  _2 ;  TypeData3  _3 ; TypeData4 _4 ;
        TypeData5 _5 ;  TypeData6  _6 ;  TypeData7  _7 ; TypeData8 _8 ;
        TypeData9 _9 ;  TypeData10 _10;  TypeData11 _11;

        ZtStTuple<Type1, Type2, Type3, Type4, Type5, Type6, Type7, Type8, Type9, Type10, Type11>(){}
        ZtStTuple<Type1, Type2, Type3, Type4, Type5, Type6, Type7, Type8, Type9, Type10, Type11>
            (
                Type1 _T1, Type2  _T2 , Type3  _T3 , Type4 _T4,
                Type5 _T5, Type6  _T6 , Type7  _T7 , Type8 _T8,
                Type9 _T9, Type10 _T10, Type11 _T11
            ) :
                _1 (CCheckRef1 ::PassData(_T1 ))
              , _2 (CCheckRef2 ::PassData(_T2 ))
              , _3 (CCheckRef3 ::PassData(_T3 ))
              , _4 (CCheckRef4 ::PassData(_T4 ))
              , _5 (CCheckRef5 ::PassData(_T5 ))
              , _6 (CCheckRef6 ::PassData(_T6 ))
              , _7 (CCheckRef7 ::PassData(_T7 ))
              , _8 (CCheckRef8 ::PassData(_T8 ))
              , _9 (CCheckRef9 ::PassData(_T9 ))
              , _10(CCheckRef10::PassData(_T10))
              , _11(CCheckRef11::PassData(_T11))
        {}
    };
    /*###########################################################################################*/
    template
        <   typename Type1 , typename Type2 , typename Type3 ,
            typename Type4 , typename Type5 , typename Type6 ,
            typename Type7 , typename Type8 , typename Type9 ,
            typename Type10, typename Type11, typename Type12
        >
    struct ZtStTuple
        <
            Type1, Type2, Type3, Type4 , Type5 , Type6 ,
            Type7, Type8, Type9, Type10, Type11, Type12
        >
    {
        typedef ZNsMain::ZtCCheckRef<Type1 >   CCheckRef1 ;
        typedef ZNsMain::ZtCCheckRef<Type2 >   CCheckRef2 ;
        typedef ZNsMain::ZtCCheckRef<Type3 >   CCheckRef3 ;
        typedef ZNsMain::ZtCCheckRef<Type4 >   CCheckRef4 ;
        typedef ZNsMain::ZtCCheckRef<Type5 >   CCheckRef5 ;
        typedef ZNsMain::ZtCCheckRef<Type6 >   CCheckRef6 ;
        typedef ZNsMain::ZtCCheckRef<Type7 >   CCheckRef7 ;
        typedef ZNsMain::ZtCCheckRef<Type8 >   CCheckRef8 ;
        typedef ZNsMain::ZtCCheckRef<Type9 >   CCheckRef9 ;
        typedef ZNsMain::ZtCCheckRef<Type10>   CCheckRef10;
        typedef ZNsMain::ZtCCheckRef<Type11>   CCheckRef11;
        typedef ZNsMain::ZtCCheckRef<Type12>   CCheckRef12;

        typedef typename CCheckRef1 ::TypeData TypeData1  ;
        typedef typename CCheckRef2 ::TypeData TypeData2  ;
        typedef typename CCheckRef3 ::TypeData TypeData3  ;
        typedef typename CCheckRef4 ::TypeData TypeData4  ;
        typedef typename CCheckRef5 ::TypeData TypeData5  ;
        typedef typename CCheckRef6 ::TypeData TypeData6  ;
        typedef typename CCheckRef7 ::TypeData TypeData7  ;
        typedef typename CCheckRef8 ::TypeData TypeData8  ;
        typedef typename CCheckRef9 ::TypeData TypeData9  ;
        typedef typename CCheckRef10::TypeData TypeData10 ;
        typedef typename CCheckRef11::TypeData TypeData11 ;
        typedef typename CCheckRef12::TypeData TypeData12 ;

        TypeData1 _1 ;  TypeData2  _2 ;  TypeData3  _3 ; TypeData4  _4 ;
        TypeData5 _5 ;  TypeData6  _6 ;  TypeData7  _7 ; TypeData8  _8 ;
        TypeData9 _9 ;  TypeData10 _10;  TypeData11 _11; TypeData12 _12;

        ZtStTuple<Type1, Type2, Type3, Type4, Type5, Type6, Type7, Type8, Type9, Type10, Type11, Type12>(){}
        ZtStTuple<Type1, Type2, Type3, Type4, Type5, Type6, Type7, Type8, Type9, Type10, Type11, Type12>
            (
                Type1 _T1, Type2  _T2 , Type3  _T3 , Type4  _T4 ,
                Type5 _T5, Type6  _T6 , Type7  _T7 , Type8  _T8 ,
                Type9 _T9, Type10 _T10, Type11 _T11, Type12 _T12
            ) :
                _1 (CCheckRef1 ::PassData(_T1 ))
              , _2 (CCheckRef2 ::PassData(_T2 ))
              , _3 (CCheckRef3 ::PassData(_T3 ))
              , _4 (CCheckRef4 ::PassData(_T4 ))
              , _5 (CCheckRef5 ::PassData(_T5 ))
              , _6 (CCheckRef6 ::PassData(_T6 ))
              , _7 (CCheckRef7 ::PassData(_T7 ))
              , _8 (CCheckRef8 ::PassData(_T8 ))
              , _9 (CCheckRef9 ::PassData(_T9 ))
              , _10(CCheckRef10::PassData(_T10))
              , _11(CCheckRef11::PassData(_T11))
              , _12(CCheckRef12::PassData(_T12))
        {}
    };
    /*###########################################################################################*/




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

    ■  RVO(Return Value Optimization) 로 인해 아래가 가능하다. -- 2025-09-06 21:23

        int VariMy=0; ZtStTuple<int&> myt1 = ZftMakeTuple(ZftMCP(VariMy));

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



    ZtStTuple<> ZftMakeTuple()
    {
        return ZtStTuple<>();
    }
    /*####################################################################*/


    template
        <typename Type1>
    ZtStTuple /*::::::::::::::::::::::::::::::::::::::::::::::::::::::::::*/
        <typename ZNsMain::ZtCCheckRef<Type1>::TypeData>
    ZftMakeTuple(Type1 _T1)
    {
        typedef ZNsMain::ZtCCheckRef<Type1>   CCheckRef1 ;

        typedef typename CCheckRef1::TypeData TypeData1  ;

        return ZtStTuple<TypeData1> /*::::::::::::::::::::::::::::::::::::*/
            (
                CCheckRef1::PassData(_T1)
            );
    }
    /*####################################################################*/


    template
        <typename Type1, typename Type2>
    ZtStTuple /*::::::::::::::::::::::::::::::::::::::::::::::::::::::::::*/
        <
            typename ZNsMain::ZtCCheckRef<Type1>::TypeData
          , typename ZNsMain::ZtCCheckRef<Type2>::TypeData
        >
    ZftMakeTuple(Type1 _T1, Type2 _T2)
    {
        typedef ZNsMain::ZtCCheckRef<Type1>   CCheckRef1 ;
        typedef ZNsMain::ZtCCheckRef<Type2>   CCheckRef2 ;

        typedef typename CCheckRef1::TypeData TypeData1  ;
        typedef typename CCheckRef2::TypeData TypeData2  ;

        return ZtStTuple<TypeData1, TypeData2> /*:::::::::::::::::::::::::*/
            (
                CCheckRef1::PassData(_T1)
              , CCheckRef2::PassData(_T2)
            );
    }
    /*####################################################################*/


    template
        <typename Type1, typename Type2, typename Type3>
    ZtStTuple /*::::::::::::::::::::::::::::::::::::::::::::::::::::::::::*/
        <
            typename ZNsMain::ZtCCheckRef<Type1>::TypeData
          , typename ZNsMain::ZtCCheckRef<Type2>::TypeData
          , typename ZNsMain::ZtCCheckRef<Type3>::TypeData
        >
    ZftMakeTuple(Type1 _T1, Type2 _T2, Type3 _T3)
    {
        typedef ZNsMain::ZtCCheckRef<Type1>   CCheckRef1 ;
        typedef ZNsMain::ZtCCheckRef<Type2>   CCheckRef2 ;
        typedef ZNsMain::ZtCCheckRef<Type3>   CCheckRef3 ;

        typedef typename CCheckRef1::TypeData TypeData1  ;
        typedef typename CCheckRef2::TypeData TypeData2  ;
        typedef typename CCheckRef3::TypeData TypeData3  ;

        return ZtStTuple<TypeData1, TypeData2, TypeData3> /*::::::::::::::*/
            (
                CCheckRef1::PassData(_T1)
              , CCheckRef2::PassData(_T2)
              , CCheckRef3::PassData(_T3)
            );
    }
    /*####################################################################*/


    template
        < typename Type1, typename Type2, typename Type3, typename Type4 >
    ZtStTuple /*::::::::::::::::::::::::::::::::::::::::::::::::::::::::::*/
        <
            typename ZNsMain::ZtCCheckRef<Type1>::TypeData
          , typename ZNsMain::ZtCCheckRef<Type2>::TypeData
          , typename ZNsMain::ZtCCheckRef<Type3>::TypeData
          , typename ZNsMain::ZtCCheckRef<Type4>::TypeData
        >
    ZftMakeTuple /*#######################################################*/
        (
            Type1 _T1, Type2 _T2, Type3 _T3, Type4 _T4
        )
    /*####################################################################*/
    {
        typedef ZNsMain::ZtCCheckRef<Type1>   CCheckRef1 ;
        typedef ZNsMain::ZtCCheckRef<Type2>   CCheckRef2 ;
        typedef ZNsMain::ZtCCheckRef<Type3>   CCheckRef3 ;
        typedef ZNsMain::ZtCCheckRef<Type4>   CCheckRef4 ;

        typedef typename CCheckRef1::TypeData TypeData1  ;
        typedef typename CCheckRef2::TypeData TypeData2  ;
        typedef typename CCheckRef3::TypeData TypeData3  ;
        typedef typename CCheckRef4::TypeData TypeData4  ;

        return ZtStTuple<TypeData1, TypeData2, TypeData3, TypeData4> /*:::*/
            (
                CCheckRef1::PassData(_T1)
              , CCheckRef2::PassData(_T2)
              , CCheckRef3::PassData(_T3)
              , CCheckRef4::PassData(_T4)
            );
    }
    /*####################################################################*/


    template< typename Type1, typename Type2,
              typename Type3, typename Type4, typename Type5
            >
    ZtStTuple /*::::::::::::::::::::::::::::::::::::::::::::::::::::::::::*/
        <
            typename ZNsMain::ZtCCheckRef<Type1>::TypeData
          , typename ZNsMain::ZtCCheckRef<Type2>::TypeData
          , typename ZNsMain::ZtCCheckRef<Type3>::TypeData
          , typename ZNsMain::ZtCCheckRef<Type4>::TypeData
          , typename ZNsMain::ZtCCheckRef<Type5>::TypeData
        >
    ZftMakeTuple /*#######################################################*/
        (
            Type1 _T1, Type2 _T2, Type3 _T3, Type4 _T4, Type5 _T5
        )
    /*####################################################################*/
    {
        typedef ZNsMain::ZtCCheckRef<Type1>   CCheckRef1 ;
        typedef ZNsMain::ZtCCheckRef<Type2>   CCheckRef2 ;
        typedef ZNsMain::ZtCCheckRef<Type3>   CCheckRef3 ;
        typedef ZNsMain::ZtCCheckRef<Type4>   CCheckRef4 ;
        typedef ZNsMain::ZtCCheckRef<Type5>   CCheckRef5 ;

        typedef typename CCheckRef1::TypeData TypeData1  ;
        typedef typename CCheckRef2::TypeData TypeData2  ;
        typedef typename CCheckRef3::TypeData TypeData3  ;
        typedef typename CCheckRef4::TypeData TypeData4  ;
        typedef typename CCheckRef5::TypeData TypeData5  ;

        return ZtStTuple /*:::::::::::::::::::::::::::::::::::::::::::::::*/
            <
                TypeData1, TypeData2,
                TypeData3, TypeData4, TypeData5
            >
            (
                CCheckRef1::PassData(_T1)
              , CCheckRef2::PassData(_T2)
              , CCheckRef3::PassData(_T3)
              , CCheckRef4::PassData(_T4)
              , CCheckRef5::PassData(_T5)
            );
    }
    /*####################################################################*/


    template< typename Type1, typename Type2, typename Type3,
              typename Type4, typename Type5, typename Type6
            >
    ZtStTuple /*::::::::::::::::::::::::::::::::::::::::::::::::::::::::::*/
        <
            typename ZNsMain::ZtCCheckRef<Type1>::TypeData
          , typename ZNsMain::ZtCCheckRef<Type2>::TypeData
          , typename ZNsMain::ZtCCheckRef<Type3>::TypeData
          , typename ZNsMain::ZtCCheckRef<Type4>::TypeData
          , typename ZNsMain::ZtCCheckRef<Type5>::TypeData
          , typename ZNsMain::ZtCCheckRef<Type6>::TypeData
        >
    ZftMakeTuple /*#######################################################*/
        (
            Type1 _T1, Type2 _T2, Type3 _T3, Type4 _T4, Type5 _T5, Type6 _T6
        )
    /*####################################################################*/
    {
        typedef ZNsMain::ZtCCheckRef<Type1>   CCheckRef1 ;
        typedef ZNsMain::ZtCCheckRef<Type2>   CCheckRef2 ;
        typedef ZNsMain::ZtCCheckRef<Type3>   CCheckRef3 ;
        typedef ZNsMain::ZtCCheckRef<Type4>   CCheckRef4 ;
        typedef ZNsMain::ZtCCheckRef<Type5>   CCheckRef5 ;
        typedef ZNsMain::ZtCCheckRef<Type6>   CCheckRef6 ;

        typedef typename CCheckRef1::TypeData TypeData1  ;
        typedef typename CCheckRef2::TypeData TypeData2  ;
        typedef typename CCheckRef3::TypeData TypeData3  ;
        typedef typename CCheckRef4::TypeData TypeData4  ;
        typedef typename CCheckRef5::TypeData TypeData5  ;
        typedef typename CCheckRef6::TypeData TypeData6  ;

        return ZtStTuple /*:::::::::::::::::::::::::::::::::::::::::::::::*/
            <
                TypeData1, TypeData2, TypeData3,
                TypeData4, TypeData5, TypeData6
            >
            (
                CCheckRef1::PassData(_T1)
              , CCheckRef2::PassData(_T2)
              , CCheckRef3::PassData(_T3)
              , CCheckRef4::PassData(_T4)
              , CCheckRef5::PassData(_T5)
              , CCheckRef6::PassData(_T6)
            );
    }
    /*####################################################################*/


    template< typename Type1, typename Type2, typename Type3,
              typename Type4, typename Type5, typename Type6, typename Type7
            >
    ZtStTuple /*::::::::::::::::::::::::::::::::::::::::::::::::::::::::::*/
        <
            typename ZNsMain::ZtCCheckRef<Type1>::TypeData
          , typename ZNsMain::ZtCCheckRef<Type2>::TypeData
          , typename ZNsMain::ZtCCheckRef<Type3>::TypeData
          , typename ZNsMain::ZtCCheckRef<Type4>::TypeData
          , typename ZNsMain::ZtCCheckRef<Type5>::TypeData
          , typename ZNsMain::ZtCCheckRef<Type6>::TypeData
          , typename ZNsMain::ZtCCheckRef<Type7>::TypeData
        >
    ZftMakeTuple /*#######################################################*/
        (
            Type1 _T1, Type2 _T2, Type3 _T3, Type4 _T4,
            Type5 _T5, Type6 _T6, Type7 _T7
        )
    /*####################################################################*/
    {
        typedef ZNsMain::ZtCCheckRef<Type1>   CCheckRef1 ;
        typedef ZNsMain::ZtCCheckRef<Type2>   CCheckRef2 ;
        typedef ZNsMain::ZtCCheckRef<Type3>   CCheckRef3 ;
        typedef ZNsMain::ZtCCheckRef<Type4>   CCheckRef4 ;
        typedef ZNsMain::ZtCCheckRef<Type5>   CCheckRef5 ;
        typedef ZNsMain::ZtCCheckRef<Type6>   CCheckRef6 ;
        typedef ZNsMain::ZtCCheckRef<Type7>   CCheckRef7 ;

        typedef typename CCheckRef1::TypeData TypeData1  ;
        typedef typename CCheckRef2::TypeData TypeData2  ;
        typedef typename CCheckRef3::TypeData TypeData3  ;
        typedef typename CCheckRef4::TypeData TypeData4  ;
        typedef typename CCheckRef5::TypeData TypeData5  ;
        typedef typename CCheckRef6::TypeData TypeData6  ;
        typedef typename CCheckRef7::TypeData TypeData7  ;

        return ZtStTuple /*:::::::::::::::::::::::::::::::::::::::::::::::*/
            <
                TypeData1, TypeData2, TypeData3, TypeData4,
                TypeData5, TypeData6, TypeData7
            >
            (
                CCheckRef1::PassData(_T1)
              , CCheckRef2::PassData(_T2)
              , CCheckRef3::PassData(_T3)
              , CCheckRef4::PassData(_T4)
              , CCheckRef5::PassData(_T5)
              , CCheckRef6::PassData(_T6)
              , CCheckRef7::PassData(_T7)
            );
    }
    /*####################################################################*/


    template< typename Type1, typename Type2, typename Type3,
              typename Type4, typename Type5, typename Type6,
              typename Type7, typename Type8
            >
    ZtStTuple /*::::::::::::::::::::::::::::::::::::::::::::::::::::::::::*/
        <
            typename ZNsMain::ZtCCheckRef<Type1>::TypeData
          , typename ZNsMain::ZtCCheckRef<Type2>::TypeData
          , typename ZNsMain::ZtCCheckRef<Type3>::TypeData
          , typename ZNsMain::ZtCCheckRef<Type4>::TypeData
          , typename ZNsMain::ZtCCheckRef<Type5>::TypeData
          , typename ZNsMain::ZtCCheckRef<Type6>::TypeData
          , typename ZNsMain::ZtCCheckRef<Type7>::TypeData
          , typename ZNsMain::ZtCCheckRef<Type8>::TypeData
        >
    ZftMakeTuple /*#######################################################*/
        (
            Type1 _T1, Type2 _T2, Type3 _T3, Type4 _T4,
            Type5 _T5, Type6 _T6, Type7 _T7, Type8 _T8
        )
    /*####################################################################*/
    {
        typedef ZNsMain::ZtCCheckRef<Type1>   CCheckRef1 ;
        typedef ZNsMain::ZtCCheckRef<Type2>   CCheckRef2 ;
        typedef ZNsMain::ZtCCheckRef<Type3>   CCheckRef3 ;
        typedef ZNsMain::ZtCCheckRef<Type4>   CCheckRef4 ;
        typedef ZNsMain::ZtCCheckRef<Type5>   CCheckRef5 ;
        typedef ZNsMain::ZtCCheckRef<Type6>   CCheckRef6 ;
        typedef ZNsMain::ZtCCheckRef<Type7>   CCheckRef7 ;
        typedef ZNsMain::ZtCCheckRef<Type8>   CCheckRef8 ;

        typedef typename CCheckRef1::TypeData TypeData1  ;
        typedef typename CCheckRef2::TypeData TypeData2  ;
        typedef typename CCheckRef3::TypeData TypeData3  ;
        typedef typename CCheckRef4::TypeData TypeData4  ;
        typedef typename CCheckRef5::TypeData TypeData5  ;
        typedef typename CCheckRef6::TypeData TypeData6  ;
        typedef typename CCheckRef7::TypeData TypeData7  ;
        typedef typename CCheckRef8::TypeData TypeData8  ;

        return ZtStTuple /*:::::::::::::::::::::::::::::::::::::::::::::::*/
            <
                TypeData1, TypeData2, TypeData3, TypeData4,
                TypeData5, TypeData6, TypeData7, TypeData8
            >
            (
                CCheckRef1::PassData(_T1)
              , CCheckRef2::PassData(_T2)
              , CCheckRef3::PassData(_T3)
              , CCheckRef4::PassData(_T4)
              , CCheckRef5::PassData(_T5)
              , CCheckRef6::PassData(_T6)
              , CCheckRef7::PassData(_T7)
              , CCheckRef8::PassData(_T8)
            );
    }
    /*####################################################################*/


    template< typename Type1, typename Type2, typename Type3,
              typename Type4, typename Type5, typename Type6,
              typename Type7, typename Type8, typename Type9
            >
    ZtStTuple /*::::::::::::::::::::::::::::::::::::::::::::::::::::::::::*/
        <
            typename ZNsMain::ZtCCheckRef<Type1>::TypeData
          , typename ZNsMain::ZtCCheckRef<Type2>::TypeData
          , typename ZNsMain::ZtCCheckRef<Type3>::TypeData
          , typename ZNsMain::ZtCCheckRef<Type4>::TypeData
          , typename ZNsMain::ZtCCheckRef<Type5>::TypeData
          , typename ZNsMain::ZtCCheckRef<Type6>::TypeData
          , typename ZNsMain::ZtCCheckRef<Type7>::TypeData
          , typename ZNsMain::ZtCCheckRef<Type8>::TypeData
          , typename ZNsMain::ZtCCheckRef<Type9>::TypeData
        >
    ZftMakeTuple /*#######################################################*/
        (
            Type1 _T1, Type2 _T2, Type3 _T3, Type4 _T4,
            Type5 _T5, Type6 _T6, Type7 _T7, Type8 _T8, Type9 _T9
        )
    /*####################################################################*/
    {
        typedef ZNsMain::ZtCCheckRef<Type1>   CCheckRef1 ;
        typedef ZNsMain::ZtCCheckRef<Type2>   CCheckRef2 ;
        typedef ZNsMain::ZtCCheckRef<Type3>   CCheckRef3 ;
        typedef ZNsMain::ZtCCheckRef<Type4>   CCheckRef4 ;
        typedef ZNsMain::ZtCCheckRef<Type5>   CCheckRef5 ;
        typedef ZNsMain::ZtCCheckRef<Type6>   CCheckRef6 ;
        typedef ZNsMain::ZtCCheckRef<Type7>   CCheckRef7 ;
        typedef ZNsMain::ZtCCheckRef<Type8>   CCheckRef8 ;
        typedef ZNsMain::ZtCCheckRef<Type9>   CCheckRef9 ;

        typedef typename CCheckRef1::TypeData TypeData1  ;
        typedef typename CCheckRef2::TypeData TypeData2  ;
        typedef typename CCheckRef3::TypeData TypeData3  ;
        typedef typename CCheckRef4::TypeData TypeData4  ;
        typedef typename CCheckRef5::TypeData TypeData5  ;
        typedef typename CCheckRef6::TypeData TypeData6  ;
        typedef typename CCheckRef7::TypeData TypeData7  ;
        typedef typename CCheckRef8::TypeData TypeData8  ;
        typedef typename CCheckRef9::TypeData TypeData9  ;

        return ZtStTuple /*:::::::::::::::::::::::::::::::::::::::::::::::*/
            <
                TypeData1, TypeData2, TypeData3, TypeData4,
                TypeData5, TypeData6, TypeData7, TypeData8, TypeData9
            >
            (
                CCheckRef1::PassData(_T1)
              , CCheckRef2::PassData(_T2)
              , CCheckRef3::PassData(_T3)
              , CCheckRef4::PassData(_T4)
              , CCheckRef5::PassData(_T5)
              , CCheckRef6::PassData(_T6)
              , CCheckRef7::PassData(_T7)
              , CCheckRef8::PassData(_T8)
              , CCheckRef9::PassData(_T9)
            );
    }
    /*####################################################################*/


    template< typename Type1, typename Type2, typename Type3,
              typename Type4, typename Type5, typename Type6,
              typename Type7, typename Type8, typename Type9, typename Type10
            >
    ZtStTuple /*::::::::::::::::::::::::::::::::::::::::::::::::::::::::::*/
        <
            typename ZNsMain::ZtCCheckRef<Type1 >::TypeData
          , typename ZNsMain::ZtCCheckRef<Type2 >::TypeData
          , typename ZNsMain::ZtCCheckRef<Type3 >::TypeData
          , typename ZNsMain::ZtCCheckRef<Type4 >::TypeData
          , typename ZNsMain::ZtCCheckRef<Type5 >::TypeData
          , typename ZNsMain::ZtCCheckRef<Type6 >::TypeData
          , typename ZNsMain::ZtCCheckRef<Type7 >::TypeData
          , typename ZNsMain::ZtCCheckRef<Type8 >::TypeData
          , typename ZNsMain::ZtCCheckRef<Type9 >::TypeData
          , typename ZNsMain::ZtCCheckRef<Type10>::TypeData
        >
    ZftMakeTuple /*#######################################################*/
        (
            Type1 _T1, Type2  _T2 , Type3 _T3, Type4 _T4,
            Type5 _T5, Type6  _T6 , Type7 _T7, Type8 _T8,
            Type9 _T9, Type10 _T10
        )
    /*####################################################################*/
    {
        typedef ZNsMain::ZtCCheckRef<Type1 >   CCheckRef1 ;
        typedef ZNsMain::ZtCCheckRef<Type2 >   CCheckRef2 ;
        typedef ZNsMain::ZtCCheckRef<Type3 >   CCheckRef3 ;
        typedef ZNsMain::ZtCCheckRef<Type4 >   CCheckRef4 ;
        typedef ZNsMain::ZtCCheckRef<Type5 >   CCheckRef5 ;
        typedef ZNsMain::ZtCCheckRef<Type6 >   CCheckRef6 ;
        typedef ZNsMain::ZtCCheckRef<Type7 >   CCheckRef7 ;
        typedef ZNsMain::ZtCCheckRef<Type8 >   CCheckRef8 ;
        typedef ZNsMain::ZtCCheckRef<Type9 >   CCheckRef9 ;
        typedef ZNsMain::ZtCCheckRef<Type10>   CCheckRef10;

        typedef typename CCheckRef1 ::TypeData TypeData1  ;
        typedef typename CCheckRef2 ::TypeData TypeData2  ;
        typedef typename CCheckRef3 ::TypeData TypeData3  ;
        typedef typename CCheckRef4 ::TypeData TypeData4  ;
        typedef typename CCheckRef5 ::TypeData TypeData5  ;
        typedef typename CCheckRef6 ::TypeData TypeData6  ;
        typedef typename CCheckRef7 ::TypeData TypeData7  ;
        typedef typename CCheckRef8 ::TypeData TypeData8  ;
        typedef typename CCheckRef9 ::TypeData TypeData9  ;
        typedef typename CCheckRef10::TypeData TypeData10 ;

        return ZtStTuple /*:::::::::::::::::::::::::::::::::::::::::::::::*/
            <
                TypeData1, TypeData2, TypeData3, TypeData4,
                TypeData5, TypeData6, TypeData7, TypeData8,
                TypeData9, TypeData10
            >
            (
                CCheckRef1 ::PassData(_T1 )
              , CCheckRef2 ::PassData(_T2 )
              , CCheckRef3 ::PassData(_T3 )
              , CCheckRef4 ::PassData(_T4 )
              , CCheckRef5 ::PassData(_T5 )
              , CCheckRef6 ::PassData(_T6 )
              , CCheckRef7 ::PassData(_T7 )
              , CCheckRef8 ::PassData(_T8 )
              , CCheckRef9 ::PassData(_T9 )
              , CCheckRef10::PassData(_T10)
            );
    }
    /*####################################################################*/


    template< typename Type1 , typename Type2, typename Type3,
              typename Type4 , typename Type5, typename Type6,
              typename Type7 , typename Type8, typename Type9,
              typename Type10, typename Type11
            >
    ZtStTuple /*::::::::::::::::::::::::::::::::::::::::::::::::::::::::::*/
        <
            typename ZNsMain::ZtCCheckRef<Type1 >::TypeData
          , typename ZNsMain::ZtCCheckRef<Type2 >::TypeData
          , typename ZNsMain::ZtCCheckRef<Type3 >::TypeData
          , typename ZNsMain::ZtCCheckRef<Type4 >::TypeData
          , typename ZNsMain::ZtCCheckRef<Type5 >::TypeData
          , typename ZNsMain::ZtCCheckRef<Type6 >::TypeData
          , typename ZNsMain::ZtCCheckRef<Type7 >::TypeData
          , typename ZNsMain::ZtCCheckRef<Type8 >::TypeData
          , typename ZNsMain::ZtCCheckRef<Type9 >::TypeData
          , typename ZNsMain::ZtCCheckRef<Type10>::TypeData
          , typename ZNsMain::ZtCCheckRef<Type11>::TypeData
        >
    ZftMakeTuple /*#######################################################*/
        (
            Type1 _T1, Type2  _T2 , Type3  _T3 , Type4 _T4,
            Type5 _T5, Type6  _T6 , Type7  _T7 , Type8 _T8,
            Type9 _T9, Type10 _T10, Type11 _T11
        )
    /*####################################################################*/
    {
        typedef ZNsMain::ZtCCheckRef<Type1 >   CCheckRef1 ;
        typedef ZNsMain::ZtCCheckRef<Type2 >   CCheckRef2 ;
        typedef ZNsMain::ZtCCheckRef<Type3 >   CCheckRef3 ;
        typedef ZNsMain::ZtCCheckRef<Type4 >   CCheckRef4 ;
        typedef ZNsMain::ZtCCheckRef<Type5 >   CCheckRef5 ;
        typedef ZNsMain::ZtCCheckRef<Type6 >   CCheckRef6 ;
        typedef ZNsMain::ZtCCheckRef<Type7 >   CCheckRef7 ;
        typedef ZNsMain::ZtCCheckRef<Type8 >   CCheckRef8 ;
        typedef ZNsMain::ZtCCheckRef<Type9 >   CCheckRef9 ;
        typedef ZNsMain::ZtCCheckRef<Type10>   CCheckRef10;
        typedef ZNsMain::ZtCCheckRef<Type11>   CCheckRef11;

        typedef typename CCheckRef1 ::TypeData TypeData1  ;
        typedef typename CCheckRef2 ::TypeData TypeData2  ;
        typedef typename CCheckRef3 ::TypeData TypeData3  ;
        typedef typename CCheckRef4 ::TypeData TypeData4  ;
        typedef typename CCheckRef5 ::TypeData TypeData5  ;
        typedef typename CCheckRef6 ::TypeData TypeData6  ;
        typedef typename CCheckRef7 ::TypeData TypeData7  ;
        typedef typename CCheckRef8 ::TypeData TypeData8  ;
        typedef typename CCheckRef9 ::TypeData TypeData9  ;
        typedef typename CCheckRef10::TypeData TypeData10 ;
        typedef typename CCheckRef11::TypeData TypeData11 ;

        return ZtStTuple /*:::::::::::::::::::::::::::::::::::::::::::::::*/
            <
                TypeData1, TypeData2 , TypeData3, TypeData4,
                TypeData5, TypeData6 , TypeData7, TypeData8,
                TypeData9, TypeData10, TypeData11
            >
            (
                CCheckRef1 ::PassData(_T1 )
              , CCheckRef2 ::PassData(_T2 )
              , CCheckRef3 ::PassData(_T3 )
              , CCheckRef4 ::PassData(_T4 )
              , CCheckRef5 ::PassData(_T5 )
              , CCheckRef6 ::PassData(_T6 )
              , CCheckRef7 ::PassData(_T7 )
              , CCheckRef8 ::PassData(_T8 )
              , CCheckRef9 ::PassData(_T9 )
              , CCheckRef10::PassData(_T10)
              , CCheckRef11::PassData(_T11)
            );
    }
    /*####################################################################*/


    template< typename Type1 , typename Type2 , typename Type3,
              typename Type4 , typename Type5 , typename Type6,
              typename Type7 , typename Type8 , typename Type9,
              typename Type10, typename Type11, typename Type12
            >
    ZtStTuple /*::::::::::::::::::::::::::::::::::::::::::::::::::::::::::*/
        <
            typename ZNsMain::ZtCCheckRef<Type1 >::TypeData
          , typename ZNsMain::ZtCCheckRef<Type2 >::TypeData
          , typename ZNsMain::ZtCCheckRef<Type3 >::TypeData
          , typename ZNsMain::ZtCCheckRef<Type4 >::TypeData
          , typename ZNsMain::ZtCCheckRef<Type5 >::TypeData
          , typename ZNsMain::ZtCCheckRef<Type6 >::TypeData
          , typename ZNsMain::ZtCCheckRef<Type7 >::TypeData
          , typename ZNsMain::ZtCCheckRef<Type8 >::TypeData
          , typename ZNsMain::ZtCCheckRef<Type9 >::TypeData
          , typename ZNsMain::ZtCCheckRef<Type10>::TypeData
          , typename ZNsMain::ZtCCheckRef<Type11>::TypeData
          , typename ZNsMain::ZtCCheckRef<Type12>::TypeData
        >
    ZftMakeTuple /*#######################################################*/
        (
            Type1 _T1, Type2  _T2 , Type3  _T3 , Type4  _T4 ,
            Type5 _T5, Type6  _T6 , Type7  _T7 , Type8  _T8 ,
            Type9 _T9, Type10 _T10, Type11 _T11, Type12 _T12
        )
    /*####################################################################*/
    {
        typedef ZNsMain::ZtCCheckRef<Type1 >   CCheckRef1 ;
        typedef ZNsMain::ZtCCheckRef<Type2 >   CCheckRef2 ;
        typedef ZNsMain::ZtCCheckRef<Type3 >   CCheckRef3 ;
        typedef ZNsMain::ZtCCheckRef<Type4 >   CCheckRef4 ;
        typedef ZNsMain::ZtCCheckRef<Type5 >   CCheckRef5 ;
        typedef ZNsMain::ZtCCheckRef<Type6 >   CCheckRef6 ;
        typedef ZNsMain::ZtCCheckRef<Type7 >   CCheckRef7 ;
        typedef ZNsMain::ZtCCheckRef<Type8 >   CCheckRef8 ;
        typedef ZNsMain::ZtCCheckRef<Type9 >   CCheckRef9 ;
        typedef ZNsMain::ZtCCheckRef<Type10>   CCheckRef10;
        typedef ZNsMain::ZtCCheckRef<Type11>   CCheckRef11;
        typedef ZNsMain::ZtCCheckRef<Type12>   CCheckRef12;

        typedef typename CCheckRef1 ::TypeData TypeData1  ;
        typedef typename CCheckRef2 ::TypeData TypeData2  ;
        typedef typename CCheckRef3 ::TypeData TypeData3  ;
        typedef typename CCheckRef4 ::TypeData TypeData4  ;
        typedef typename CCheckRef5 ::TypeData TypeData5  ;
        typedef typename CCheckRef6 ::TypeData TypeData6  ;
        typedef typename CCheckRef7 ::TypeData TypeData7  ;
        typedef typename CCheckRef8 ::TypeData TypeData8  ;
        typedef typename CCheckRef9 ::TypeData TypeData9  ;
        typedef typename CCheckRef10::TypeData TypeData10 ;
        typedef typename CCheckRef11::TypeData TypeData11 ;
        typedef typename CCheckRef12::TypeData TypeData12 ;

        return ZtStTuple /*:::::::::::::::::::::::::::::::::::::::::::::::*/
            <
                TypeData1, TypeData2 , TypeData3 , TypeData4,
                TypeData5, TypeData6 , TypeData7 , TypeData8,
                TypeData9, TypeData10, TypeData11, TypeData12
            >
            (
                CCheckRef1 ::PassData(_T1 )
              , CCheckRef2 ::PassData(_T2 )
              , CCheckRef3 ::PassData(_T3 )
              , CCheckRef4 ::PassData(_T4 )
              , CCheckRef5 ::PassData(_T5 )
              , CCheckRef6 ::PassData(_T6 )
              , CCheckRef7 ::PassData(_T7 )
              , CCheckRef8 ::PassData(_T8 )
              , CCheckRef9 ::PassData(_T9 )
              , CCheckRef10::PassData(_T10)
              , CCheckRef11::PassData(_T11)
              , CCheckRef12::PassData(_T12)
            );
    }
    /*####################################################################*/



    template<   typename TTypeArg1,
                typename TTypeArg2,
                bool     TTypebCompareObj=true
            >
    class ZtCCompare /////////////////////////
    {
    public:
        enum {ZEUseCompareObj=(ZTypIntE)TTypebCompareObj};
    public:

        template<typename TTypeArg11, typename TTypeArg22>
            static ZTypInt Exec(TTypeArg11 AR_TypeArg1, TTypeArg22 AR_TypeArg2)
        {
        #ifdef _DEBUG_CCOMPARE_EXEC
            cout<<"    ※※ ZtCCompare<TTypeArg1, TTypeArg2, true> is called."<<endl;
        #endif //_DEBUG_CCOMPARE_EXEC

            return AR_TypeArg1.Compare(AR_TypeArg2);
        }/*
        template<typename TTypeArg11, typename TTypeArg22>
            static ZTypInt Exec(TTypeArg11 AR_TypeArg1, TTypeArg22 AR_TypeArg2) */

    public:
    };/*
    template<   typename TTypeArg1,
                typename TTypeArg2,
                bool     TTypebCompareObj=true
            >
    class ZtCCompare ///////////////////////*/


    template<typename TTypeArg1, typename TTypeArg2
            >
    class ZtCCompare<TTypeArg1, TTypeArg2, false>
    {
    public:
        enum {ZEUseCompareObj=0};
    public:

        template<typename TTypeArg11, typename TTypeArg22>
            static ZTypInt Exec(TTypeArg11 AR_TypeArg1, TTypeArg22 AR_TypeArg2)
        {
            return ZNsEnum::ZECompareResult_Equal;
        }/*
        template<typename TTypeArg11, typename TTypeArg22>
            static ZTypInt Exec(TTypeArg1 AR_TypeArg1, TTypeArg2 AR_TypeArg2)*/

    public:
    };/*
    template<typename TTypeArg1, typename TTypeArg2
            >
    class ZtCCompare<TTypeArg1, TTypeArg2, false> */


    template<> class ZtCCompare<ZTypInt, ZTypInt, true>
    {
    public:
        enum {ZEUseCompareObj=1};
    public:

        static ZTypInt Exec(ZTypInt AI_Int1, ZTypInt AI_Int2)
        {
        #ifdef   _DEBUG_CCOMPARE_EXEC
            cout<<"    ※※ ZtCCompare<int, int, true> is called."<<endl;
        #endif //_DEBUG_CCOMPARE_EXEC

            return AI_Int1 - AI_Int2 ;
        }/*
        static ZTypInt Exec(ZTypInt AI_Int1, ZTypInt AI_Int2)*/

    public:
    };/*
    template<> class ZtCCompare<ZTypInt, ZTypInt, true>*/



    namespace ZNsHide
    {
        /* 특정 클래스 안에서만 사용되어, 사용자가 그 존재를 알 필요가 없는 클래스를 둔다. */
    }/*
    namespace ZNsHide*/

    namespace ZNsIn
    {
        /*///////////////////////////////////////////////////////////////////////////////

        ■  특정 메인 클래스에 종속되어 사용되는 클래스가 있고, 메인 클래스가 생성될 때 등,
            아주 잠시만 필요한 클래스가 있다면 ZNsIn~ 접두어로 시작하는 namespace 에 둔다.
            ZNsHide 에 두자니 한 번은 명시적으로 사용을 하니까 Hidden 되지는 않기 때문에,
            이렇게 하자. 이를테면 CIocp 클래스가 있는데, 이 클래스의 생성자에서 CHelpIocp
            클래스를 인수로 받고, 그 후 CHelpIocp 는 사용자가 직접 사용할 일이 없다면 이 클
            래스는 namespace ZNsInIOCP 에 둘 수 있겠다.

            -- 2009-12-21 12:56:00

        ///////////////////////////////////////////////////////////////////////////////*/
    }/*
    namespace ZNsIn*/

    namespace ZNsTmplParam
    {
    }/*
    namespace ZNsTmplParam*/

    namespace ZNsBase
    {
        // 가상 클래스도 아니고 인터페이스 전용의 함수도 아니면서
        // 주로 기반 클래스로 사용되는 클래스는 여기에 둔다.
    }/*
    namespace ZNsBase*/

    namespace ZNsSngt
    {
        /*////////////////////////////////////////////////////////////////////////////////////////////

        ■  singleton 으로 사용되는 object 들을 가져오는 함수나 object 들은 여기에 둔다.
            singleton 으로 사용되는 object 들은 여기에 두지말고, CSngt 라는 접두어를 사용할 수도 있다.

        ////////////////////////////////////////////////////////////////////////////////////////////*/
    }/*
    namespace ZNsSngt*/

    namespace ZNsSttc
    {
        /*/////////////////////////////////////////////////////////////////////////////

        ■  static 멤버만을 갖는 object 들은 여기에 두거나 CSttc 라는 접두어를 사용한다.

            -- 2010-03-10 19:58:00

        /////////////////////////////////////////////////////////////////////////////*/
    }/*
    namespace ZNsSttc*/

    namespace ZNsReent
    {
        /*////////////////////////////////////////////////////////////

        ■  ZNsReent : namespace Reentrant

            어떤 자료 구조가 thread safe 한 경우와, 그렇지 않은 경우를
            따로 구현한다면 thread safe 한 구조를 여기에 둔다.

        ////////////////////////////////////////////////////////////*/
    }/*
    namespace ZNsReent*/

    namespace ZNsArg
    {
        /*////////////////////////////////////////////////////////////////

        ■  쓰레드의 Call Back 함수와 같이 어떤 함수가 특정한 자료를 포인터
            로 받고 있는데, 이 포인터가 특수한 사정으로 여러 자료형의 object
            의 포인터를 받아야 할 때, 해당 object 들의 포인터를 class 로 묶
            고 이 클래스 object 의 포인터로 사용하면 되는데, 이와 같은 용도
            로 사용하는 클래스는 여기에 둔다.

            쓰레드의 Call Back 함수라면 아예 그 함수 내부에서 내포 클래스로
            정의해버리는 것이 더 좋을 것 같다.

            -- 2010-01-02 22:11:00

        ////////////////////////////////////////////////////////////////*/
    }/*
    namespace ZNsArg*/

    namespace ZNsDeco
    {
        /*////////////////////////////////////////////////////////////////

        ■  어떤 클래스(템플릿)이 거의 같은 기능을 하지만, Decoration 패턴
            을 사용하는 클래스와, 그렇지 않은 클래스가 쌍으로 존재할 때,
            Decoration 패턴을 사용하는 클래스는 주로 namespace ZNsDeco 에 둔
            다. 즉, Logic 과 View 구조에서, View 에 해당하는 클래스를 생성
            자에서 (주로 참조로) 전달받는 클래스 템플릿이 주요 대상이다.

            -- 2010-03-10 22:04:00

        ////////////////////////////////////////////////////////////////*/
    }/*
    namespace ZNsDeco*/

    namespace ZNsView
    {
        /*//////////////////////////////////////////////////////////////////////////////////

        ■  'Logic-View 구조'(일반적으로는 Document-View 구조라고 얘기를 하는데, 그보다는
            'Logic-View 구조'라고 하는 것이 더 적절한 것 같다)에서 View 에 해당하는 클래스는
            여기에 놓는다. 여기에 있는 클래스는 접두어 CView 붙여도 좋을 것 같다.

            접두어 CView 를 붙이지 않아도, namespace ZNsView 에 있다면 그 클래스는 View 라는
            것을 알 수 있는데, 그렇다면 접두어 CView 을 붙일 것인지 말 것인지는, 그때그때 상
            황에 맡기기로 하자.

            -- 2011-09-11 13:50:00

        //////////////////////////////////////////////////////////////////////////////////*/
    }/*
    namespace ZNsView*/

    namespace ZNsViewIFace
    {
        /*//////////////////////////////////////////////////////////////////////////////////

        ■  'Logic-View 구조'에서 View 에 해당하는 어떤 클래스의 interface 를 알려주는 클래스는
            여기에 놓는다.

            -- 2011-09-11 13:54:00

        //////////////////////////////////////////////////////////////////////////////////*/
    }/*
    namespace ZNsViewIFace*/

    namespace ZNsCRTP
    {
        /*//////////////////////////////////////////////////

        ■  CRTP : CURIOUSLY RECURRING TEMPLATE PATTERN

            CRTP 를 사용하는 클래스 템플릿은 주로 여기에 둔다.

            -- 2010-03-12 13:51:00

        //////////////////////////////////////////////////*/
    }/*
    namespace ZNsCRTP*/

    namespace ZNsHelp
    {
        /*//////////////////////////////////////////////////

        ■  주로 특정 클래스에 도움이 되는 클래스는 여기에 둔다.

            -- 2025-09-13 00:59:00

        //////////////////////////////////////////////////*/
    }/*
    namespace ZNsHelp*/

    namespace ZNsFunc
    {

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

        ■  특수한 목적으로 쓰이는 전역 템플릿 함수는 여기에 놓는다.

        ■  ZftMoveFast<>(Type1& AR_Type1, Type2& AR_Type2)

            차기 표준에서 구현하는 RValue Reference 를 흉내낸 함수다. Move 생성자와
            Move 대입연산 중 대입연산만을 흉내내는 것이며, 일반적으로 이 함수 호출후에
            AR_Type2 의 크기는 0 이 되거나 줄어들 것이다.

            해당 object 에 Move 대입연산이 필요하면 해당 object 를 인수로 갖는
            ZftMoveFast() 함수 템플릿을 전문화하면 된다.

        ■  어느 함수 func()가 인수로 전달되는 object 의 초기/종료 멤버함수를 요구하는
            경우, 그때마다 해당 object class 를 선언할 때, 특정한 이름의 초기/종료 멤버
            함수를 선언/정의해야 하는데, 이런 불편함을 약간이라도 감소시키기 위해, func()
            에서 해당 object 를 인수로 갖는 전역함수 __Init<>(), __Fini<>() 를 호출하는
            것으로 하면 다소 편해질 것이다. 그 후 필요에 따라, __Init, __Fini 템플릿을
            전문화하면 된다.

            현재(2025-08-20) __init() 와 __Fini() 는 _CODE_OLD_ 으로 사실상 삭제되었다.

        ■  -- 2009-08-15 19:57:00

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

        template<typename Type1, typename Type2>
            void ZftMoveFast(Type1& AR_Type1, Type2& AR_Type2)
        {
        #ifdef _DEBUG_FAST_MOVE_OBJ_
            cout<<"    ※※ ZftMoveFast Start : Type1="<<typeid(Type1).name()<<", Type2="<<typeid(Type2).name()<<endl;
        #endif //_DEBUG_FAST_MOVE_OBJ_

            AR_Type1 = AR_Type2 ;

        #ifdef _DEBUG_FAST_MOVE_OBJ_
            cout<<"    ※※ ZftMoveFast Close : Type2="<<typeid(Type1).name()<<", Type2="<<typeid(Type2).name()<<endl;
        #endif //_DEBUG_FAST_MOVE_OBJ_
        }/*
        template<typename Type1, typename Type2>
            void ZftMoveFast(Type& AR_Type1, Type& AR_Type2) */


#if(_CODE_OLD_)
        template<typename Type> void __Init(Type& AR_Type)
        {
        #ifdef _DEBUG
            cout<<"void ZNsFunc::__Init<Type>(Type&), Type="<<typeid(Type).name()<<endl;
        #endif //_DEBUG
        }/*
        template<typename Type> void __Init(Type& AR_Type)*/

        template<typename Type> void __Fini(Type& AR_Type)
        {
        #ifdef _DEBUG
            cout<<"void ZNsFunc::__Fini<Type>(Type&), Type="<<typeid(Type).name()<<endl;
        #endif //_DEBUG
        }/*
        template<typename Type> void __Fini(Type& AR_Type)*/
#endif //(_CODE_OLD_)


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

        ■  CObjAVL<> 등의 클래스에서 object 를 추가하거나 삭제할 때, 아래 중첩 함수를
            각각 1 회 씩 최대 2 회 수행하게 되는데,

                bool operator> (~)
                bool operator==(~)

            이를 꼭 1 번만 수행하도록 줄이기 위해 (클래스이지만 실은 함수인)

                int ZtCCompare<>::Exec(TTypeArg1 AR_TypeArg1, TTypeArg2 AR_TypeArg2)

            를 사용한다.

            -- 2012-09-01 20:13:00

            AR_Type1==AR_Type2 이면 ZNsEnum::ZECompareResult_Equal          ,
            AR_Type1>=AR_Type2 이면 ZNsEnum::ZECompareResult_Equal 이상의 값,
            AR_Type1> AR_Type2 이면 ZNsEnum::ZECompareResult_More  이상의 값,
            AR_Type1<=AR_Type2 이면 ZNsEnum::ZECompareResult_Equal 이하의 값,
            AR_Type1< AR_Type2 이면 ZNsEnum::ZECompareResult_Less  이하의 값,

            을 리턴하거나

            AR_Type1>=AR_Type2 이면 ZNsEnum::ZECompareResult_Equal 이상의    값,
            AR_Type1> AR_Type2 이면 ZNsEnum::ZECompareResult_Equal 보다 큰   값,
            AR_Type1<=AR_Type2 이면 ZNsEnum::ZECompareResult_Equal 이하의    값,
            AR_Type1< AR_Type2 이면 ZNsEnum::ZECompareResult_Equal 보다 작은 값,

            을 리턴한다.

            -- 2012-09-01 20:20:00

            최초에는

                template<typename Type1,typename Type2> __CompareObj(Type1, Type2)

            라는 함수를 만들어 사용했는데, 템플릿 중첩 정의 시에 상당히 불편했었다.
            분명히 문법에 맞게 썼는 것 같은데, 컴파일 에러가 자꾸 나고... 단순히 문
            법에 안맞게 써서 그렇다고 한 마디 말로 표현하기에는 어려운 상황이다.

            -- 2012-09-02 22:49:00

            ZtCCompare<>::Exec(~) 가 template 함수로 선언되어 있는데, 이전에는 template
            함수가 아니었다. 이것을 template 함수로 바꾼 이유는 ZtCCompare<> 의 template
            인자에 TTypeArg1, TTypeArg2  에 구애받지 않기 위해서다. 따라서 확장성이
            약간 상승한다.

            -- 2012-10-09 09:14:00

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

    }/*
    namespace ZNsFunc*/



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

    ■  ZtCMoveObj<> 의 사용례는 CObjAVL.H 에 있다.

        -- 2013-08-26 19:18:00
    
    /////////////////////////////////////////////*/

    template<   typename TTypeArg1 ,
                typename TTypeArg2 ,
                bool     TTypebMoveObj=true
            >
    class ZtCMoveObj /*###############################################*/
    {
    public:
        enum {ZEUseMoveObj = (ZTypIntE)TTypebMoveObj} ;
    public:
        typedef typename ZNsMain::ZtCRef<TTypeArg1>::TypeRef TypeRef1;
        typedef typename ZNsMain::ZtCRef<TTypeArg2>::TypeRef TypeRef2;
    public:

        static void Exec(TypeRef1 AR_TypeArg1, TypeRef2 AR_TypeArg2)
        {
        #ifdef   _DEBUG_MOVEOBJ_EXEC
            cout<<"    ※※ ZtCMoveObj<TTypeArg1, TTypeArg2, true> is called."<<endl;
        #endif //_DEBUG_MOVEOBJ_EXEC

            ZNsFunc::ZftMoveFast(AR_TypeArg1, AR_TypeArg2);
        }/*
        static void Exec(TTypeArg1& AR_TypeArg1, TTypeArg2& AR_TypeArg2)*/

    public:
    };/*
    template<   typename TTypeArg1 ,
                typename TTypeArg2 ,
                bool     TTypebMoveObj=true
            >
    class ZtCMoveObj #################################################*/


    template  /*######################################################*/
        <
            typename TTypeArg1, typename TTypeArg2
        >
    class ZtCMoveObj<TTypeArg1, TTypeArg2, false> /*//////////////////*/
    {
    public:
        enum {ZEUseMoveObj=0};
    public:
        typedef typename ZNsMain::ZtCRef<TTypeArg1>::TypeRef TypeRef1;
        typedef typename ZNsMain::ZtCRef<TTypeArg2>::TypeRef TypeRef2;
    public:

        static void Exec(TypeRef1 AR_TypeArg1, TypeRef2 AR_TypeArg2)
        {
            AR_TypeArg1 = AR_TypeArg2 ;
        }/*
        static void Exec(TypeRef1 AR_TypeArg1, TypeRef2 AR_TypeArg2)*/

    public:
    };/*
    template ###########################################################
        <
            typename TTypeArg1, typename TTypeArg2
        >
    class ZtCMoveObj<TTypeArg1, TTypeArg2, false> ////////////////////*/



    namespace ZNsTmplChain
    {

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

        ■  ZtCTmplChain<> 와 유사한 인터페이스를 이용하여, 마치 chain
            처럼 호출하는 구조를 갖는 클래스를 여기에 둔다.

            -- 2011-08-05 21:16:00

            사용례는 CMainChars.H 의

                TTypeLength CSearchCursor_T<>::GetLengthByTmplChain(~)

            함수를 참고한다.

            -- 2011-08-06 23:51:00

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

        template<   typename TTypeNow, typename TTypeNext
                >
        class ZtCTmplChain //////////////////////////////
        {
        public :
            typedef TTypeNow  ZCObjNow ;
            typedef TTypeNext ZCObjNext;
        public :
            enum{ZENextObjNo  =ZCObjNext::ENextObjNo+1};
            enum{ZEBoolNextObj=1                      };
        private:
            TTypeNow  mo_ZCObjNow ;
            TTypeNext mo_ZCObjNext;
        public :
                  ZCObjNow&  GetNowObj ()      {return mo_ZCObjNow ;}
                  ZCObjNext& GetNextObj()      {return mo_ZCObjNext;}
            /*#####################################################*/
            const ZCObjNow&  GetNowObj () const{return mo_ZCObjNow ;}
            const ZCObjNext& GetNextObj() const{return mo_ZCObjNext;}
        public:
        };/*
        template<   typename TTypeNow, typename TTypeNext
                >
        class ZtCTmplChain ////////////////////////////*/


        template<typename TTypeNow> class ZtCTmplChain<TTypeNow, ZCEmpty>
        {
        public :
            typedef TTypeNow ZCObjNow ;
            typedef TTypeNow ZCObjNext;
        public :
            enum{ZENextObjNo  =1};
            enum{ZEBoolNextObj=0};
        private:
            ZCObjNow  mo_ZCObjNow;
        public :
                  ZCObjNow&  GetNowObj ()      {return mo_ZCObjNow;}
                  ZCObjNext& GetNextObj()      {return mo_ZCObjNow;}
            /*####################################################*/
            const ZCObjNow&  GetNowObj () const{return mo_ZCObjNow;}
            const ZCObjNext& GetNextObj() const{return mo_ZCObjNow;}
        public:
        };/*
        template<typename TTypeNow> class ZtCTmplChain<TTypeNow, ZCEmpty> */


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

        ■  ZtCTmplTreeChain<> 와 유사한 인터페이스를 이용하여, 마치 chain 의 tree 처럼
            호출하는 구조를 갖는 클래스를, ZtCTmplChain<> 와 같은 namespace 에 둔다.

            -- 2011-10-04 00:46:00

            일종의 2진 트리 형태인데, GetNextObj2() 멤버로 호출하는 노드를 따라서 먼저
            처리를 끝내는지, 아니면 GetNextObj() 멤버로 호출하는 노드를 따라서 먼저 처리할
            것인지는 경우에 따라 다르다. 일반적으로는 GetNextObj2() 멤버로 호출하는 노드를
            따라서 먼저 처리를 하는 것으로 정한다.

            -- 2011-10-04 21:01:00

            사용례는 CMainChars.H 의

                TTypeLength CSearchCursor_T<>::GetLengthByTmplTreeChain(~)

            함수를 참고한다.

            -- 2011-10-04 00:53:00

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

        template<   typename TTypeNow  ,
                    typename TTypeNext ,
                    typename TTypeNext2
                >
        class ZtCTmplTreeChain /////////
        {
        public :
            enum{ZENextObjNo   =TTypeNext ::ENextObjNo +1};
            enum{ZENextObjNo2  =TTypeNext2::ENextObjNo2+1};
            enum{ZEBoolNextObj =1};
            enum{ZEBoolNextObj2=1};
            enum{ZEObjChainCnt =TTypeNext::EObjChainCnt+TTypeNext2::EObjChainCnt+2};
        public :
            typedef TTypeNow   ZCObjNow  ;
            typedef TTypeNext  ZCObjNext ;
            typedef TTypeNext2 ZCObjNext2;
        private:
            ZCObjNow   mo_ZCObjNow  ;
            ZCObjNext  mo_ZCObjNext ;
            ZCObjNext2 mo_ZCObjNext2;
        public :
            ZCObjNow&         GetNowObj  ()      {return mo_ZCObjNow  ;}
            ZCObjNext&        GetNextObj ()      {return mo_ZCObjNext ;}
            ZCObjNext2&       GetNextObj2()      {return mo_ZCObjNext2;}
            /*########################################################*/
            const ZCObjNow&   GetNowObj  () const{return mo_ZCObjNow  ;}
            const ZCObjNext&  GetNextObj () const{return mo_ZCObjNext ;}
            const ZCObjNext2& GetNextObj2() const{return mo_ZCObjNext2;}
        public :
        };/*
        template<   typename TTypeNow  ,
                    typename TTypeNext ,
                    typename TTypeNext2
                >
        class ZtCTmplTreeChain ///////*/


        template<   typename TTypeNow, typename TTypeNext
                >
        class ZtCTmplTreeChain<TTypeNow, TTypeNext, ZCEmpty>
        {
        public :
            enum{ZENextObjNo   =TTypeNext::ENextObjNo  +1};
            enum{ZENextObjNo2  =0                        };
            enum{ZEBoolNextObj =1                        };
            enum{ZEBoolNextObj2=0                        };
            enum{ZEObjChainCnt =TTypeNext::EObjChainCnt+1};
        public :
            typedef TTypeNow   ZCObjNow  ;
            typedef TTypeNext  ZCObjNext ;
            typedef TTypeNext  ZCObjNext2; // interface 호환을 위해서만 존재.
        private:
            ZCObjNow   mo_ZCObjNow ;
            ZCObjNext  mo_ZCObjNext;
        public :
            ZCObjNow&         GetNowObj  ()      {return mo_ZCObjNow ;}
            ZCObjNext&        GetNextObj ()      {return mo_ZCObjNext;}
            ZCObjNext2&       GetNextObj2()      {return mo_ZCObjNext;} // interface 호환을 위해서만 존재.
            /*#######################################################*/
            const ZCObjNow&   GetNowObj  () const{return mo_ZCObjNow ;}
            const ZCObjNext&  GetNextObj () const{return mo_ZCObjNext;}
            const ZCObjNext2& GetNextObj2() const{return mo_ZCObjNext;} // interface 호환을 위해서만 존재.
        public :
        };/*
        template<   typename TTypeNow, typename TTypeNext
                >
        class ZtCTmplTreeChain<TTypeNow, TTypeNext, ZCEmpty> */

        template<   typename TTypeNow, typename TTypeNext2
                >
        class ZtCTmplTreeChain<TTypeNow, ZCEmpty, TTypeNext2>
        {
        public :
            enum{ZENextObjNo   =0                          };
            enum{ZENextObjNo2  =TTypeNext2::ENextObjNo2 +1 };
            enum{ZEBoolNextObj =0                          };
            enum{ZEBoolNextObj2=1                          };
            enum{ZEObjChainCnt =TTypeNext2::EObjChainCnt+1 };
        public :
            typedef TTypeNow   ZCObjNow  ;
            typedef TTypeNext2 ZCObjNext ; // interface 호환을 위해서만 존재.
            typedef TTypeNext2 ZCObjNext2;
        private:
            ZCObjNow   mo_ZCObjNow  ;
            ZCObjNext2 mo_ZCObjNext2;
        public :
            ZCObjNow&         GetNowObj  ()      {return mo_ZCObjNow  ;}
            ZCObjNext&        GetNextObj ()      {return mo_ZCObjNext2;} // interface 호환을 위해서만 존재.
            ZCObjNext2&       GetNextObj2()      {return mo_ZCObjNext2;}
            /*########################################################*/
            const ZCObjNow&   GetNowObj  () const{return mo_ZCObjNow  ;}
            const ZCObjNext&  GetNextObj () const{return mo_ZCObjNext2;} // interface 호환을 위해서만 존재.
            const ZCObjNext2& GetNextObj2() const{return mo_ZCObjNext2;}
        public :
        };/*
        template<   typename TTypeNow , typename TTypeNext2
                >
        class ZtCTmplTreeChain<TTypeNow, ZCEmpty, TTypeNext2> */

        template<   typename TTypeNow ////////////////////
                >
        class ZtCTmplTreeChain<TTypeNow, ZCEmpty, ZCEmpty>
        {
        public :
            enum{ZENextObjNo   =0};
            enum{ZENextObjNo2  =0};
            enum{ZEBoolNextObj =0};
            enum{ZEBoolNextObj2=0};
            enum{ZEObjChainCnt =1};
        public :
            typedef TTypeNow ZCObjNow  ;
            typedef ZCObjNow ZCObjNext ; // interface 호환을 위해서만 존재.
            typedef ZCObjNow ZCObjNext2; // interface 호환을 위해서만 존재.
        private:
            ZCObjNow mo_ZCObjNow;
        public :
            ZCObjNow&         GetNowObj  ()      {return mo_ZCObjNow;}
            ZCObjNext&        GetNextObj ()      {return mo_ZCObjNow;} // interface 호환을 위해서만 존재.
            ZCObjNext2&       GetNextObj2()      {return mo_ZCObjNow;} // interface 호환을 위해서만 존재.
            /*######################################################*/
            const ZCObjNow&   GetNowObj  () const{return mo_ZCObjNow;} // interface 호환을 위해서만 존재.
            const ZCObjNext&  GetNextObj () const{return mo_ZCObjNow;} // interface 호환을 위해서만 존재.
            const ZCObjNext2& GetNextObj2() const{return mo_ZCObjNow;} // interface 호환을 위해서만 존재.
        public :
        };/*
        template<   typename TTypeNow ////////////////////
                >
        class ZtCTmplTreeChain<TTypeNow, ZCEmpty, ZCEmpty>
        */
    }/*
    namespace ZNsTmplChain*/


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

    ■  함수가 어떤 조건에서 실행을 중지할 때,
        bool 값으로 표시해도 되지만 가독성을 위해서 enum ZERun 을 사용하자.

    ■  enum ZERun 의 값을 포함해서 에러 상태를 표현하고 싶을 때에는,
        enum ZERunEx 를 사용하자.

        -- 2011-09-27 05:37:00

    ■  ZEActRun

        연결 리스트 같은 자료구조에서 각 원소를 순회하면서 특정 조건에 맞
        으면 원소를 삭제하거나, 순회를 중지하는 등의 행위를 동시에 표현하
        고 싶을 때, ZEActRun 을 사용하자.

        -- 2025-10-03 19:01

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

    namespace ZNsEnum
    {

        enum ZERun
        {
            ZERun_NO, // 실행 중지
            ZERun_OK  // 실행 계속
        };/*
        enum ZERun*/

        enum ZERunEx
        {
            ZERunEx_NO, // 실행 중지
            ZERunEx_OK, // 실행 계속
            ZERunEx_Err // 실행 에러
        };/*
        enum ZERun*/

        enum ZEAct
        {
            ZEAct_NO, // (함수 등이) 어떤 조건에 맞지 않아서 아무 짓도 하지 않았다.
            ZEAct_OK  // (함수 등이) 어떤 조건에 맞아서 지정된 처리를 하였다.
        };/*
        enum ZEAct*/

        enum ZEActEx
        {
            ZEActEx_NO, // (함수 등이) 어떤 조건에 맞지 않아서 아무 짓도 하지 않았다.
            ZEActEx_OK, // (함수 등이) 어떤 조건에 맞아서 지정된 처리를 하였다.
            ZEActEx_Err // (함수 등이) 수행 중에 에러가 발생하였다.
        };/*
        enum ZEAct*/

        enum ZEActRun
        {
            ZEActRun_RunNO =0x01, // 실행 중지
            ZEActRun_RunOK =0x02, // 실행 계속
            ZEActRun_RunErr=0x04, // 실행 오류
            ZEActRun_ActNO =0x08, // 처리 중지
            ZEActRun_ActOK =0xA0, // 처리 계속
            ZEActRun_ActErr=0xB0  // 처리 오류
        };/*
        enum ZEAct*/


        enum ZEThrowFinally
        {
            ZEThrowFinally_NO,
            ZEThrowFinally_OK
        };/*
        enum ZEThrowFinally*/

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

        ■  타 언어의 throw ~ catch ~ finally 를 흉내낼 때
            EThrowFinally 예외를 던진다.

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

    }/*
    namespace ZNsEnum*/


    using ZNsEnum::ZERun      ;
    using ZNsEnum::ZERun_NO   ;
    using ZNsEnum::ZERun_OK   ;

    using ZNsEnum::ZERunEx    ;
    using ZNsEnum::ZERunEx_NO ;
    using ZNsEnum::ZERunEx_OK ;
    using ZNsEnum::ZERunEx_Err;


    namespace ZNsIFace
    {

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

        ■  class ZIDelgtMSG 는 C# 의 delegate 삼아서 만든 클래스.

            어느 object 가 하나 이상의 다른 object 에게 어떤 메시지를 전달하고 싶을 때, 메시지를
            전송하는 object 는, 수신하는 object 의 기반클래스 ZIDelgtMSG 의 참조나 포인터를 멤버
            로 가지고 있다가, ZIDelgtMSG::SendMSG() 나 ZIDelgtMSG::RecvMSG() 을 호출하면 된다.

        ■  COM 개념을 상당부분 포함하고 있다. 간단하게 COM 대용으로 써도 될 듯 하다.

            -- 2009-03-08 02:26:00

        ■  class ZIDelgtMSG 를 상속하여 추가 멤버함수를 가진 인터페이스를 구현하는 클래스일 경우
            에는 namespace ZNsIFace 에 두지 말고 namespace ZNsIDelgt 에 두자.

            -- 2009-03-08 19:17:00

        ■  A, B, C 클래스가 서로의 존재를 알아야 한다고 할 때도 사용할 수 있겠다. 그런데 이런 경
            우는 굳이 ZIDelgtMSG 를 사용하지 말고, 단순 가상 함수 클래스를 사용해도 된다. 그게 더
            간단할 것이다. 그래도 ZIDelgtMSG 를 사용한다면, interface 의 일관성을 얻을 수 있다는 게
            장점이 될 수 있다.

            -- 2010-03-13 22:28:00

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

        class ZIDelgtMSG
        {
        public:
            enum ZEIMsg{ZEIMsg_NO=0, ZEIMsg_OK=1};
        public:

            virtual ~ZIDelgtMSG(){}

            virtual ZTypLLong GetTypeID() const
            {
                return 0;
            }/*
            virtual ZTypLLong GetTypeID() const*/

            virtual const char* GetTypeName() const
            {
                return 0;
            }/*
            virtual const char* GetTypeID() const*/

            virtual ZTypLLong GetIMSGPtrOfID(ZTypLLong AI_TypeID, ZIDelgtMSG*& APR_ZIDelgtMSG)
            {
                APR_ZIDelgtMSG=0; return ZEIMsg_OK;
            }/*
            virtual ZTypLLong GetIMSGPtrOfID(ZTypLLong AI_TypeID, ZIDelgtMSG*R APR_ZIDelgtMSG)*/

            virtual ZTypIntPtr SendMSG(ZIDelgtMSG& ArZIDelgtMSG, ZTypIntI AI_MsgNo, const char* ApcMsgData, ZTypIntI AI_MsgLen, void* AP_Void=0, ...)
            {
                return ZEIMsg_OK;
            }/*
            virtual ZTypIntPtr SendMSG(ZIDelgtMSG& ArZIDelgtMSG, ZTypIntI AI_MsgNo, const char* ApcMsgData, ZTypIntI AI_MsgLen,void* AP_Void=0, ...)*/

            virtual ZTypIntPtr RecvMSG(ZTypIntI AI_MsgNo, const char* ApcMsgData, ZTypLength AI_MsgLen, void* AP_Void=0, ...)
            {
                return ZEIMsg_OK;
            }/*
            virtual ZTypIntPtr RecvMSG(ZTypIntI AI_MsgNo, const char* ApcMsgData, ZTypLength AI_MsgLen, void* AP_Void=0, ...)*/

        public:
        };/*
        class ZIDelgtMSG*/

    }/*
    namespace ZNsIFace*/


    namespace ZNsIDelgt
    {
        // class ZIDelgtMSG 를 상속하여 추가 멤버함수를 가진
        // 인터페이스를 구현하는 클래스일 경우에는 여기에 둔다.
    }/*
    namespace ZNsIDelgt*/


    class ZCAllocator
    {
    public:
        static void* operator new  (size_t AL_AllocSize                     ){return ::malloc(AL_AllocSize);}
        static void* operator new[](size_t AL_AllocSize                     ){return ::malloc(AL_AllocSize);}
        static void* operator new  (size_t AL_AllocSize, void* AP_AllocBegin){return AP_AllocBegin         ;}
        static void* operator new[](size_t AL_AllocSize, void* AP_AllocBegin){return AP_AllocBegin         ;}

        static void operator delete  (void* AP_Void){if(AP_Void!=0) ::free(AP_Void);}
        static void operator delete[](void* AP_Void){if(AP_Void!=0) ::free(AP_Void);}
    public:
    };/*
    class ZCAllocator*/


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

    ■  class ZCAllocator     는 정적   멤버를 사용하지만
        class ZtCAllocClass<> 는 비정적 멤버를 사용한다.

    ■  기본메모리 할당자로 ZtCAllocClass<> 을 사용하는 클래스가 나중에
        다른 할당 알고리즘을 사용하고 싶을 때는 ZtCAllocClass<> 템플릿을
        해당 Type 으로 전문화시켜주면 된다.

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

    template<typename TType> class ZtCAllocClass : public ZCAllocator
    {
    public:
        TType* InitMem   (size_t AL_AllocSize){return (TType*)::malloc(AL_AllocSize)              ;}
        TType* InitArrMem(size_t AL_AllocSize){return (TType*)::malloc(AL_AllocSize*sizeof(TType));}
    public:
        void   FiniMem   (void* AP_Void){if(AP_Void!=0) ::free(AP_Void);}
    public:
    };/*
    template<typename TType> class ZtCAllocClass : public ZCAllocator*/


    class ZCAllocClass : public ZCAllocator
    {
    public:
        void* InitMem  (size_t AL_AllocSize){return ::malloc(AL_AllocSize) ;}
        void  FiniMem  (void*  AP_Void     ){if(AP_Void!=0) ::free(AP_Void);}
    public:
    };/*
    class ZCAllocClass : public ZCAllocator*/



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

    ■  문자열 클래스에서 새로 메모리를 증가시켜야 할 때, 필요한 메모리보다 약간 더 할
        당하는 것이 좋을 경우가 있는데, 이 경우에 필요한 메모리보다 어느 정도 만큼의 메
        모리를 할당한 것인지를 지정한다.

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

    template<typename TTypeCh> class ZtCAllocMemSize
    {
    public:

        template<typename TTypeSize> static TTypeSize
            GetNewAllocSize(TTypeSize AL_NowAllocSize, TTypeSize AL_AllAllocSize )
        {
            /*  AL_AllAllocSize : 해당 문자열 object 가 할당받은 문자 총갯수.
                AL_NowAllocSize : AL_AllAllocSize 에서 현재 유효한 문자 갯수. */

            return AL_NowAllocSize<=AL_AllAllocSize ? AL_NowAllocSize : AL_NowAllocSize*2 ;
        }/*
        template<typenanme TTypeSize> static TTypeSize
            GetNewAllocSize(TTypeSize AL_NowAllocSize, TTypeSize AL_AllAllocSize ) */

    public:
    };/*
    template<typename TTypeCh> class ZtCAllocMemSize */


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

    ■  아래 템플릿은 양방향 리스트에서 n 번째 원소에 접근할 때, 앞에
        서부터 접근하는 것이 빠를지, 뒤에서부터 접근하는 것이 빠를지
        판단할 때 사용한다.

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

    template<typename TTypSize> class ZtCShortCut
    {
    private:

        static inline TTypSize GetAbs(TTypSize AI_Param) // 인수의 절대값을 얻는다.
        {
            return (AI_Param<0 ? -AI_Param : AI_Param);
        }/*
        static inline TTypSize GetAbs(TTypSize AI_Param)*/
    /*
    private:*/
    public :

        static ZTypIntI GetAbsMinOrder(TTypSize AI_One, TTypSize AI_Two, TTypSize AI_Three)
        {
            // 세 개의 인수 중에서 절대값이 최소가 되는 수는
            // 몇 번째 인지 그 순서를 반환한다.
            // 맨 앞의 인수가 절대값이 최소면 1 을 반환한다.
            // 두 번째 인수의 절대값이 최소면 2 를 반환한다.
            // 세 번째 인수의 절대값이 최소면 3 을 반환한다.

            //  이 함수는 양방향 원형 연결리스트에서 n 번째 링크를 찾는데 쓰인다.

            return (  GetAbs(AI_One)<=GetAbs(AI_Two  ) /******/ ?
                     (GetAbs(AI_One)<=GetAbs(AI_Three) ? 1 : 3) :
                     (GetAbs(AI_Two)<=GetAbs(AI_Three) ? 2 : 3)
            /****/ );
        };/*
        static ZTypIntI GetAbsMinOrder(TTypSize AI_One,TTypSize AI_Two, TTypSize AI_Three)*/

    public:
    };/*
    template<typename TTypSize> class ZtCShortCut*/


#ifdef _WIN

    using ::GetLastError;


    inline ZTypIntI ZfGetLastError(){ return ::GetLastError(); }


    template<typename TString> static bool
        ZftGetLastErrMSG(TString& ARR_BuffCStr, ZTypIntI AI_ErrNo=0)
    {
        LPVOID VP_MsgBuff=0;  DWORD ViErrNo =
            (AI_ErrNo==0 ? ::GetLastError() : AI_ErrNo);

        const DWORD CI_RetCode = ::FormatMessage( ///////////////
                        FORMAT_MESSAGE_ALLOCATE_BUFFER |
                        FORMAT_MESSAGE_FROM_SYSTEM     |
                        FORMAT_MESSAGE_IGNORE_INSERTS           ,
                        NULL                                    ,
                        ViErrNo                                 ,
                        MAKELANGID(LANG_NEUTRAL,SUBLANG_DEFAULT),
                        (LPTSTR)&VP_MsgBuff,0,NULL
        /*//////////*/ ); ///////////////////////////////////////

        if(CI_RetCode==0) return false;

        (ARR_BuffCStr =
            ((LPCTSTR)VP_MsgBuff))(", ErrNo=")(ViErrNo);

        ::LocalFree(VP_MsgBuff); return true;
    }/*
    template<typename TString> static bool
        ZftGetLastErrMSG(TString& ARR_BuffCStr, ZTypIntI AI_ErrNo=0) */

   // defined(_WIN)
#elif defined(__unix__)

    inline ZTypIntI   GetLastError(){return errno ;} // for compatibility with windows
    inline ZTypIntI ZfGetLastError()
    {
        return errno ; // ::error 로 하면 안된다.
    }/*
    inline ZTypIntI ZfGetLastError()*/

    template<typename TString> static bool
        ZftGetLastErrMSG(TString& ARR_BuffCStr, ZTypIntI AI_ErrNo=0)
    {
        if(AI_ErrNo==0)
              ARR_BuffCStr = ::strerror(errno  );
        else  ARR_BuffCStr = ::strerror(AI_ErrNo);

        return true; // for compatibility with window
    }/*
    template<typename TString> static bool
        ZftGetLastErrMSG(TString& ARR_BuffCStr, ZTypIntI AI_ErrNo=0) */

//#elif defined(__unix__)
  #else

    inline ZTypIntI ZfGetLastError(){return errno ;}

    template<typename TString> static bool
        ZftGetLastErrMSG(TString& ARR_BuffCStr, ZTypIntI AI_ErrNo=0)
    {
        if(AI_ErrNo==0)
             ARR_BuffCStr = ::strerror(errno   );
        else ARR_BuffCStr = ::strerror(AI_ErrNo);

        return true; // for compatibility with window
    }/*
    template<typename TString> static bool
        ZftGetLastErrMSG(TString& ARR_BuffCStr, ZTypIntI AI_ErrNo=0) */

#endif


    // 절대값을 가져온다.

    template<typename TLong> TLong ZfABS(TLong AL_Value)
    {
        if(AL_Value<0) return -AL_Value;  return  AL_Value;
    }/*
    template<typename TLong> TLong ZfABS(TLong AL_Value) */

    template<typename TypeInt>
        TypeInt ZfAToInt(const char* ApcChar, ZTypIntI AI_Length)
    {
        if(AI_Length<1) return 0;

        while(AI_Length>0 && ApcChar[AI_Length-1]==' ')
            --AI_Length; // 뒤에 있는 공백을 제외.
      //while

        if(AI_Length<1) return 0;

        ZTycChar* VPC_Char   = ApcChar+AI_Length-1;
        TypeInt   VL_Temp    = 0                  ;
        TypeInt   VL_Result  = (*VPC_Char--)-'0'  ;
        TypeInt   VL_Multiple= 1                  ;

        while(--AI_Length>0)
        {
            if((VL_Temp=*VPC_Char--)<'0' || VL_Temp>'9' ) return 0;

            VL_Result += (VL_Multiple*=10)*(VL_Temp-'0') ; ////////
        }/*
        while(--AI_Length>0)*/

        return VL_Result;
    }/*
    template<typename TypeInt>
        TypeInt ZfAToInt(const char* ApcChar, ZTypIntI AI_Length) */

#ifdef _WIN

    inline ZTypLLong ZfAtoLL(const char* ApcChar)
    {
        if(ApcChar==0) return 0;  return ::_atoi64(ApcChar);
    }/*
    inline ZTypLLong ZfAtoLL(const char* ApcChar)*/

#else // !defined(_WIN)

    inline ZTypLLong ZfAtoLL(const char* ApcChar)
    {
        if(ApcChar==0) return 0;  return ::atoll(ApcChar);
    }/*
    inline ZTypLLong ZfAtoLL(const char* ApcChar)*/

#endif // !defined(_WIN)


    inline ZTypLLong ZfAtoLL(const char* ApcChar, ZTypIntI AI_Length)
    {
        return ZfAToInt<ZTypLLong>(ApcChar, AI_Length);
    }/*
    inline ZTypLLong ZfAtoL(const char* ApcChar, ZTypIntI AI_Length)*/


    inline ZTypLong ZfAtoL(const char* ApcChar)
    {
        if(ApcChar==0) return 0;  return ::atol(ApcChar);
    }/*
    inline ZTypLong ZfAtoL(const char* ApcChar)*/

    inline ZTypLong ZfAtoL(const char* ApcChar, ZTypIntI AI_Length)
    {
        return ZfAToInt<ZTypLong>(ApcChar, AI_Length);
    }/*
    inline ZTypLong ZfAtoL(const char* ApcChar, ZTypIntI AI_Length)*/


    inline ZTypIntI ZfAtoI(const char* ApcChar)
    {
        if(ApcChar==0) return 0;  return ::atoi(ApcChar);
    }/*
    inline ZTypIntI ZfAtoI(const char* ApcChar)*/

    inline ZTypIntI ZfAtoI(const char* ApcChar, ZTypIntI AI_Length)
    {
        return ZfAToInt<ZTypIntI>(ApcChar, AI_Length);
    }/*
    inline ZTypIntI ZfAtoI(const char* ApcChar, ZTypIntI AI_Length)*/

    inline double ZfAtoD(const char* ApcChar)
    {
        return ApcChar==0 ? 0 : ::atof(ApcChar) ;
    }/*
    inline double ZfAtoD(const char* ApcChar)*/




    inline ZTypLLong AtoLL(const char* ApcChar){return ZfAtoLL(ApcChar);}
    inline ZTypLong  AtoL (const char* ApcChar){return ZfAtoL (ApcChar);}
    inline ZTypIntI  AtoI (const char* ApcChar){return ZfAtoI (ApcChar);}
    inline double    AtoD (const char* ApcChar){return ZfAtoD (ApcChar);}

    inline ZTypLLong AtoLL(const char* ApcChar, ZTypIntI AI_Length)
        { return ZfAToInt<ZTypLLong>(ApcChar, AI_Length); }
    inline ZTypLong  AtoL (const char* ApcChar, ZTypIntI AI_Length)
        { return ZfAToInt<ZTypLong >(ApcChar, AI_Length); }
    inline ZTypIntI  AtoI (const char* ApcChar, ZTypIntI AI_Length)
        { return ZfAToInt<ZTypIntI >(ApcChar, AI_Length); }



    template<typename TTypeCh> inline
        ZTypLength ZftGetLength(const TTypeCh* ApcChar)
    {
        if(ApcChar==0) return 0;

        ZTypLength  VL_Length=0;

        while(*(ApcChar+VL_Length)!=_T('\0'))
            ++VL_Length;
        /*>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>*/

        return VL_Length;
    }/*
    template<typename TTypeCh> inline
        ZTypLength ZftGetLength(const TTypeCh* ApcChar) */


    template<typename TTypeSize, typename TTypeCh>
        inline TTypeSize ZftGetLengthType(const TTypeCh* ApcChar)
    {
        if(ApcChar==0) return 0;

        TTypeSize VL_Length=0  ;

        while(*(ApcChar+VL_Length)!=_T('\0'))
            ++VL_Length;
        /////////////////////////////////////

        return VL_Length;
    }/*
    template<typename TTypeSize, typename TTypeCh>
        inline TTypeSize ZftGetLengthType(const TTypeCh* ApcChar) */


    template<typename TTypeCh>
        inline ZTypLength ZftLength(const TTypeCh* ApcChar)
    {
        return ZftGetLength(ApcChar);
    }/*
    template<typename TTypeCh>
        inline ZTypLength ZftLength(const TTypeCh* ApcChar) */

    template<typename TTypeSize, typename TTypeCh>
        inline TTypeSize ZftLengthType(const TTypeCh* ApcChar)
    {
        return ZftGetLengthType<TTypeSize, TTypeCh>(ApcChar);
    }/*
    template<typename TTypeSize, typename TTypeCh>
        inline TTypeSize ZftLengthType(const TTypeCh* ApcChar) */


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

    ■  ZftCopyChars() 함수는 최대 AL_DestSize 만큼 복사하는데, ZNsWin.H 의 CRegistry 클래스
        에서 Windows 의 Strsafe.h 에 정의된 StringCchCopy() 을 대신하려고 만들었다. mingw 에
        서는 헤더 파일 Strsafe.h 이 없는 경우가 있는 것이다. 원래 StringCchCopy() 선언은 이렇다.

            HRESULT StringCchCopy(
              __out LPTSTR  pszDest,
              __in  size_t  cchDest,
              __in  LPCTSTR pszSrc
            );

            This function can return one of the following values. It is strongly recommended
            that you use the SUCCEEDED and FAILED macros to test the return value of this function.
            
        Return code

            S_OK : Source data was present, fully copied without truncation, and the resultant
                destination buffer is null-terminated.

            STRSAFE_E_INVALID_PARAMETER : The value in cchDest is either 0 or larger than STRSAFE_MAX_CCH.

            STRSAFE_E_INSUFFICIENT_BUFFER : The copy operation failed due to insufficient buffer
                space. The destination buffer contains a truncated, null-terminated version of the
                intended result. In situations where truncation is acceptable, this may not necessarily
                be seen as a failure condition.

        -- 2012-08-15 07:40:00

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

    template<typename TTypeCh, typename TTypeSize> TTypeSize
        ZftCopyChars(TTypeCh* ApcDest, TTypeSize AL_DestSize, const TTypeCh* ApcSource)
    {
        /*  ApcSource must be null-terminated. AL_DestSize
            must be equal to or more than strlen(ApcSource)+1.

            Null 문자를 포함하여 ApcDest 에 복사된 길이를 리턴한다.
        */
        typedef const TTypeCh TTypcCh;

        if(ApcSource==0) return 0 ;

        TTypeSize VL_SourceSize=0        ;
        TTypeCh*  VPC_Dest     =ApcDest  ;
        TTypcCh*  VPC_Source   =ApcSource;

        for(; VL_SourceSize<AL_DestSize; ++VL_SourceSize)
        {
            if(*ApcSource==0)
            {
                if(VL_SourceSize<AL_DestSize+1)
                    { *VPC_Dest=0;  return VL_SourceSize+1; }

                return VL_SourceSize;
            }/*
            if(*ApcSource==0)*/

            *VPC_Dest = *VPC_Source;
        }/*
        for(; VL_SourceSize<AL_DestSize; ++VL_SourceSize)*/
    }/*
    template<typename TTypeCh, typename TTypeSize> TTypeSize
        ZftCopyChars(TTypeCh* ApcDest, TTypeSize AL_DestSize, const TTypeCh* ApcSource) */



    /*######################################################################################

    ■  ZtCInit<>, ZCInit 은 주로 자유 기억 공간을 구현하는 자료 구조에서 사용한다.

        1) 자유 기억 공간에서 나오는 data 에 대하여 OnInit() 를 호출한다.
        2) 자유 기억 공간으로 가  는 data 에 대하여 OnFini() 를 호출한다.

        그런데 2) 는 자료 구조에 따라 호출하지 않을 수도 있다. 다수의 원소가 자유 기억 공간으
        로 들어갈 때, 일일이 그 모든 원소에 대해 Onfini() 를 호출하는 것은 낭비일 수 있는 것이
        다.

        -- 2025-09-11 11:00

    ■  주로 container 인 typename TType2 을 인수로 받아, container 와의 활용도롤 높이고 있다.

        -- 2025-09-11 11:03

    ######################################################################################*/

    template<typename TType> class ZtCInit
    {
    public:
        enum{ZEUseInit=0};
        enum{ZEUseFini=0};
    public:
        template<typename TType2>
            static void OnInit(TType& AR_TypeArg, TType2& AR_TypeArg2){}
        template<typename TType2>
            static void OnFini(TType& AR_TypeArg, TType2& AR_TypeArg2){}
    public:
    };/*
    template<typename TType> class ZtCInit*/


    class ZCInit
    {
    public:
        enum{ZEUseInit=0};
        enum{ZEUseFini=0};
    public:
        template<typename TType, typename TType2>
            static void OnInit(TType& AR_TypeArg, TType2& AR_TypeArg2){}
        template<typename TType, typename TType2>
            static void OnFini(TType& AR_TypeArg, TType2& AR_TypeArg2){}
    public:
    };/*
    class ZCInit*/


    class ZCExceptBase
    {
    public: void* operator()(){return 0;}
    };/*
    class ZCExceptBase*/


    // 예외 기반 클래스를 template 로 하면 여러 기법을 사용할 수 있다.

    template<   typename TType, typename TypeArg=const TType&
            >
    class ZtCExceptBase /*/////////////////////////////////*/
    {
    protected:
        TType mo_Type;
    public   :

        ZtCExceptBase(){}

        ZtCExceptBase(TypeArg TypeArgObj):mo_Type(TypeArgObj){}

        TType& operator()(){return mo_Type;}

    public   :
    };/*
    template<   typename TType, typename TypeArg=const TType&
            >
    class ZtCExceptBase ///////////////////////////////////*/


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

    ■  이 클래스를 private 상속하는 클래스에서 복사생성자와 대입연산자의 사용을 막는다.

    ■  template class 나 class member template 을 사용할 때, 인수가 class object 이고
        이 인수가 반드시 참조형으로 전달되어야하고, 복사 생성되어 전달될 수 없을때, 이를
        보장하기 위해 해당 class 를 아래 class 로부터 상속할 필요가 있다.

        이를 모르고 있다가, CAsyncServ_H 에 정의된 CAsyncServ_T<> 클래스를 사용할 때, 이
        클래스가 작업쓰레드 풀 인수로 복사 생성되어 전달되는 것을 나중에 알고 깜짝 놀랬다.

        -- 2010-12-20 23:51:00

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

    class ZCNonCopyable
    {
    private:
        ZCNonCopyable(const ZCNonCopyable& rhs){}
        ZCNonCopyable& operator=(const ZCNonCopyable& rhs){return *this;}
    public :
        ZCNonCopyable(){}
    public :
    };/*
    class ZCNonCopyable*/


    /*///////////////////////////////////////////////////////////////////////////
    
    ■  리스트나 트리 구조에서 쓰는 링크의 힙-자유 기억 공간-을 구현하는 class 는
        class ZCFreeAllocBase 를 상속한다. 이 자유 기억 공간 클래스의 object 는 힙
        에 할당한다.

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

    class ZCFreeAllocBase
    {
    public:

        virtual ~ZCFreeAllocBase(){}

        virtual long GetHeapSize() const{return 0;}
        virtual long GetMemSize () const{return 0;}

        const char* GetTypeName() const
        {
            return typeid(*this).name();
        }/*
        const char* GetTypeName() const*/

        virtual void DeleteAllInHeap(){}

    public:
    };/*
    class ZCFreeAllocBase*/


    namespace ZNsIFace
    {

        // 자료 구조에서 자유 기억 공간을 구현하는 interface

        class ZIFreeHeap
        {
        public:


            template<typename TLinkList> class ZtCBody
            {
            public:
                typedef typename TLinkList::ZCLink   ZCLink  ;
                typedef typename TLinkList::TypeSize TypeSize;
            public:

                _NP_ void RecvFreeIn(ZCLink* AP_CutLink){}
                _NP_ void RecvFreeIn /////////////////////
                    (
                        TypeSize  AL_CutCnt ,
                        ZCLink*   AP_CutHead,
                        ZCLink*   AP_CutTail
                    )
                { } //////////////////////////////////////


                _NP_ ZCLink* SendFreeOut(){}
                _NP_ void    SendFreeOut /////////////////
                    (
                        TypeSize AL_NeedCnt ,
                        ZCLink*& APR_NewHead,
                        ZCLink*& APR_NewTail
                    )
                { } //////////////////////////////////////


                _NP_ void SendFreeOutCopy /*////////////////////////////*/
                    (
                        ZCLink*  AP_LinkOrgin, TypeSize AL_FarNum   ,
                        ZCLink*& APR_HeadCopy, ZCLink*& APR_TailCopy
                    )
                { } /*//////////////////////////////////////////////////*/


                _NP_ void DeleteHeap(){}


                _NP_ void MakeEuqal(ZtCBody& rhs)
                {
                }/*
                _NP_ void MakeEuqal(ZtCBody& rhs)*/


                _NP_ TypeSize GetUseHeapSize() const
                {
                    return 0;
                }/*
                _NP_ TypeSize GetUseHeapSize() const*/

                _NP_ TypeSize GetAllHeapSize() const
                {
                    return 0;
                }/*
                _NP_ TypeSize GetAllHeapSize() const*/


                _NP_ TypeSize size() const
                {
                    return GetUseHeapSize();
                }/*
                _NP_ TypeSize size() const*/

            public:
            };/*
            template<typename TLinkList> class ZtCBody*/


        public:
        };/*
        class ZIFreeHeap*/


    }/*
    namespace ZNsIFace*/


    namespace ZNsIFaceEx
    {

        /*################################################################

        ■  자료 구조에서 자유 기억 공간을 구현하는 interface

            만약 다르게 구헌한 자유 기억 공간 class 가 필요하다면,

                단방향 연결 리스트는 ZtCFreeHeapSngl<> 를 통해 중첩 정의하고,
                양방향 연결 리스트는 ZtCFreeHeapCDL <> 를 통해 중첩 정의하자.

            이렇게 하면,

                ZtCFreeHeapSngl<>::ZCLink 와 ZtCFreeHeapCDL<>::ZCLink

            에서 friend 선언을 아래처럼 고정시켜 놓을 수 있다.

                template<int>
                    friend class ZNsIFaceEx::ZtCFreeHeapSngl ;

        ################################################################*/
        template<int TTypIListKind=0> class ZtCFreeHeapSngl // Single List
        {
        public:

            template<typename TSnglList> class ZtCBody
            {
            public:
                typedef typename TSnglList::ZCLink   ZCLink  ;
                typedef typename TSnglList::TypeSize TypeSize;

            /*:::::::::::::::::::::::::::::::::::::::::::::::::::

            ■  만약 ZCLink 의 non-public 멤버에 접근해야 하는 경우,
                ZCLink 에서 ZtCBody 에 friend 선언을 해줘야 하는 것
                이 맞겠지만, friend 선언 없이 해야 한다면, ZCLink 와
                같은 멤버를 가진 class 를 선언하고 그  class 로 강제
                형변환을 해서 해결하자.

                -- 2025-09-14 12:34

            :::::::::::::::::::::::::::::::::::::::::::::::::::*/
            public:

                _NP_ void RecvFreeIn(ZCLink* AP_CutLink){delete AP_CutLink;}
                _NP_ void RecvFreeIn ///////////////////////////////////////
                    (
                        TypeSize  AL_CutCnt ,
                        ZCLink*   AP_CutHead,
                        ZCLink*   AP_CutTail
                    )
                ////////////////////////////////////////////////////////////
                {
                    ZCLink* VP_DelLink = AP_CutHead;

                    __for0(TypeSize, i, AL_CutCnt)
                    {
                        AP_CutHead = AP_CutHead->GetNextPtr();

                        delete VP_DelLink;  VP_DelLink=AP_CutHead;
                    }/*
                    __for0(TypeSize, i, AL_CutCnt)*/
                }
                ////////////////////////////////////////////////////////////


                _NP_ ZCLink* SendFreeOut(){return new ZCLink;}
                _NP_ void    SendFreeOut ///////////////////////////////////
                    (
                        TypeSize AL_NeedCnt   ,
                        ZCLink*& APR_HeadLink ,
                        ZCLink*& APR_TailLink
                    )
                ////////////////////////////////////////////////////////////
                {
                    APR_HeadLink = new ZCLink;

                    ZCLink* VP_MakeLink = 0           ;
                    ZCLink* VP_TailLink = APR_HeadLink;

                    while(--AL_NeedCnt>0) // AL_NeedCnt - 1 번 순환
                    {
                        // AL_NeedCnt - 1 번 순환

                        VP_MakeLink = new ZCLink;

                        ZCLink::JoinLink
                            (VP_TailLink, VP_MakeLink);
                        VP_TailLink = VP_MakeLink ;
                    }/*
                    while(--AL_NeedCnt>0)*/

                    APR_TailLink = VP_TailLink;
                }
                ////////////////////////////////////////////////////////////


                _NP_ void SendFreeOutCopy /*////////////////////////////*/
                    (
                        ZCLink*  AP_LinkOrgin, TypeSize AL_FarNum   ,
                        ZCLink*& APR_HeadCopy, ZCLink*& APR_TailCopy
                    )
                //////////////////////////////////////////////////////////
                {
                    // 총 AL_FarNum+1 개의 링크가 만들어짊.

                    ZCLink* VP_MakeLink  = 0  ;
                    ZCLink* VP_TailLink  = 0  ;

                    VP_TailLink = VP_MakeLink =
                        new ZCLink( **AP_LinkOrgin );

                    APR_HeadCopy = VP_MakeLink;

                    while(--AL_FarNum >= 0)
                    {
                        AP_LinkOrgin= AP_LinkOrgin->GetNextPtr();
                        VP_MakeLink = new ZCLink(**AP_LinkOrgin);

                        ZCLink::JoinLink
                            (VP_TailLink, VP_MakeLink);

                        VP_TailLink = VP_MakeLink ;
                    }/*
                    while(--AL_FarNum >= 0)*/

                    APR_TailCopy=VP_TailLink;
                }/*
                _NP_ void SendFreeOutCopy   //////////////////////////////
                    (
                        ZCLink*  AP_LinkOrgin, TypeSize AL_FarNum   ,
                        ZCLink*& APR_HeadCopy, ZCLink*& APR_TailCopy
                    )
                ////////////////////////////////////////////////////////*/


                _NP_ void DeleteHeap(){}


                _NP_ void MakeEuqal(ZtCBody& rhs)
                {
                }/*
                _NP_ void MakeEuqal(ZtCBody& rhs)*/


                _NP_ TypeSize GetUseHeapSize() const
                {
                    return 0;
                }/*
                _NP_ TypeSize GetUseHeapSize() const*/


                _NP_ TypeSize size() const
                {
                    return GetUseHeapSize();
                }/*
                _NP_ TypeSize size() const*/

            public:
            };/*
            template<typename TSnglList> class ZtCBody*/

        public:
        };/*
        template<int TTypIListKind=0> class ZtCFreeHeapSngl*/


        template<int TTypIListKind=0> class ZtCFreeHeapCDL // Circular Double List
        {
        public:

            template<typename TLinkList> class ZtCBody
            {
            public:
                typedef typename TLinkList::ZCLink   ZCLink  ;
                typedef typename TLinkList::TypeSize TypeSize;
            public:

                _NP_ void RecvFreeIn(ZCLink* AP_CutLink){delete AP_CutLink;}
                _NP_ void RecvFreeIn ///////////////////////////////////////
                    (
                        TypeSize  AL_CutCnt ,
                        ZCLink*   AP_CutHead,
                        ZCLink*   AP_CutTail
                    )
                ////////////////////////////////////////////////////////////
                {
                    ZCLink* VP_DelLink = AP_CutHead;

                    __for0(TypeSize, i, AL_CutCnt)
                    {
                        AP_CutHead = AP_CutHead->GetNextPtr() ;

                        delete VP_DelLink;  VP_DelLink=AP_CutHead;
                    }/*
                    __for0(TypeSize, i, AL_CutCnt)*/
                }
                ////////////////////////////////////////////////////////////


                _NP_ ZCLink* SendFreeOut(){return new ZCLink;}
                _NP_ void    SendFreeOut ///////////////////////////////////
                    (
                        TypeSize AL_NeedCnt   ,
                        ZCLink*& APR_HeadLink ,
                        ZCLink*& APR_TailLink
                    )
                ////////////////////////////////////////////////////////////
                {
                    APR_HeadLink = new ZCLink;

                    ZCLink* VP_MakeLink = 0           ;
                    ZCLink* VP_TailLink = APR_HeadLink;

                    while(--AL_NeedCnt>0) // AL_NeedCnt - 1 번 순환
                    {
                        // AL_NeedCnt - 1 번 순환

                        VP_MakeLink = new ZCLink;

                        ZCLink::JoinLink
                            (VP_TailLink, VP_MakeLink);

                        VP_TailLink = VP_MakeLink ;
                    }/*
                    while(--AL_NeedCnt>0)*/

                    APR_TailLink = VP_TailLink;
                }
                ////////////////////////////////////////////////////////////


                _NP_ void SendFreeOutCopy /*////////////////////////////*/
                    (
                        ZCLink*  AP_LinkOrgin, TypeSize AL_FarNum   ,
                        ZCLink*& APR_HeadCopy, ZCLink*& APR_TailCopy
                    )
                //////////////////////////////////////////////////////////
                {
                    // 총 AL_FarNum+1 개의 링크가 만들어짊

                    ZCLink* VP_MakeLink  = 0  ;
                    ZCLink* VP_TailLink  = 0  ;

                    VP_TailLink  = VP_MakeLink =
                        new ZCLink(**AP_LinkOrgin) ;

                    APR_HeadCopy = VP_MakeLink;

                    while(--AL_FarNum >= 0)
                    {
                        AP_LinkOrgin= AP_LinkOrgin->GetNextPtr();
                        VP_MakeLink = new ZCLink(**AP_LinkOrgin);

                        ZCLink::JoinLink
                            (VP_TailLink, VP_MakeLink);

                        VP_TailLink = VP_MakeLink;
                    }/*
                    while(--AL_FarNum >= 0)*/

                    APR_TailCopy=VP_TailLink;
                }/*
                _NP_ void SendFreeOutCopy   //////////////////////////////
                    (
                        ZCLink*  AP_LinkOrgin, TypeSize AL_FarNum   ,
                        ZCLink*& APR_HeadCopy, ZCLink*& APR_TailCopy
                    )
                ////////////////////////////////////////////////////////*/


                _NP_ void DeleteHeap(){}


                _NP_ void MakeEuqal(ZtCBody& rhs)
                {
                }/*
                _NP_ void MakeEuqal(ZtCBody& rhs)*/


                _NP_ TypeSize GetUseHeapSize() const
                {
                    return 0;
                }/*
                _NP_ TypeSize GetUseHeapSize() const*/

                _NP_ TypeSize size() const
                {
                    return GetUseHeapSize();
                }/*
                TypeSize size() const*/

            public:
            };/*
            template<typename TLinkList> class ZtCBody*/


        public:
        };/*
        template<int TTypIListKind=0> class ZtCFreeHeapCDL*/

    }/*
    namespace ZNsIFaceEx*/


    namespace ZNsConst
    {
        // cf) ZtCSimList, ZtObjList

        const int CI_ListKind_Single = 10 ;
        const int CI_ListKind_Double = 20 ;
    }/*
    namespace ZNsConst*/



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

    ■  템플릿 인자를 정의할 때 참조로 하지 않은 경우에 object 의 크기가
        크면 포인터로 넘겨야 하는데, 이러면 어느 object 의 포인터인지 알
        수 있지만 그 object 에 속한 enum 형이나 typedef 선언 및 기타 자료
        형은 알 수 없다. 그래서 object 의 포인터를 포장하는 클래스 템플릿
        ZtCObjPtr<> 을 설계한다.

    ■  typedef ZtCStringBase<char    > CStringBase;
        typedef ZtCObjPtr <CStringBase> CObjectPtr ;

        라는 선언이 있으면 CStringBase::TypeChar 에 접근할 때에는

        CObjectPtr::TypeData::TypeChar 로 하면 된다.

    ■  포인터 자료형에 대하여 ZtCObjPtr<> 대신 더 간단하게
        ZtCTypeData<> 를 사용해도 된다. 이 편이 오히려 낳을 것 같다.

        -- 2010-01-24 22:25:00

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

    template
        <typename TType, typename TTypArgu=const TType&>
    class ZtCObjPtr
    {
    public   :
        typedef TType    TypeData ;
        typedef TTypArgu TypeArg  ;
    protected:
        TypeData& mr_TypeData;
    public   :

        ZtCObjPtr(TType&     AR_CData) : mr_TypeData(AR_CData          ){}
        ZtCObjPtr(ZtCObjPtr& AR_Rhs  ) : mr_TypeData(AR_Rhs.mr_TypeData){}

        TypeData* operator->(){return &mr_TypeData;}
        TypeData& operator* (){return  mr_TypeData;}
        operator  TypeData& (){return  mr_TypeData;}

        ZtCObjPtr& operator=(const ZtCObjPtr& rhs)
        {
            if(this==&rhs) return *this;

            mr_TypeData = rhs.mr_TypeData;  return *this;
        }/*
        ZtCObjPtr& operator=(const ZtCObjPtr& rhs)*/

        ZtCObjPtr& operator=(TTypArgu AO_ArguData)
        {
            mr_TypeData = AO_ArguData;  return *this;
        }/*
        ZtCObjPtr& operator=(TTypArgu AO_ArguData)*/

    public   :
    };/*
    template<typename TType> class ZtCObjPtr */


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

    ■  object 를 heap 에 생성하고, 참조 카운트를 이용하여 관리.

        -- 2014-07-20 04:49:00

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

    template<   typename TType, typename TAllocClass=ZCAllocClass
            >
    class ZtCObjNew : public TAllocClass ////////////////////////
    {
    public :
        typedef TType       TypeData   ;
        typedef TAllocClass ZCAllocator;
        typedef TAllocClass ZCAlloClass;
    private:

        struct StTypeRefCnt
        {
            TType   MO_TypeData;
            ZTypInt MI_RefCount;

            StTypeRefCnt(){MI_RefCount=0;}
        };/*
        struct StTypeRefCnt*/

    private:
        StTypeRefCnt* mp_StTypeRefCnt;
    public :

        ZtCObjNew()
        {
            mp_StTypeRefCnt = (StTypeRefCnt*)
                this->ZCAllocator::InitMem(sizeof(StTypeRefCnt));
            mp_StTypeRefCnt->MI_RefCount = 1 ;

            new(&mp_StTypeRefCnt->MO_TypeData) TypeData;
        }/*
        ZtCObjNew()*/

        ZtCObjNew(const TypeData& AR_TypeData)
        {
            mp_StTypeRefCnt = (StTypeRefCnt*)
                this->ZCAllocator::InitMem(sizeof(StTypeRefCnt));
            mp_StTypeRefCnt->MI_RefCount = 1 ;

            new(&mp_StTypeRefCnt->MO_TypeData) TypeData(AR_TypeData);
        }/*
        ZtCObjNew(const TypeData& AR_TypeData)*/

        template<typename TTypeArg1, typename TTypeArg2>
            ZtCObjNew(TTypeArg1& ArTTypeArg1, TTypeArg2& ArTTypeArg2)
        {
            mp_StTypeRefCnt = (StTypeRefCnt*)
                this->ZCAllocator::InitMem(sizeof(StTypeRefCnt));
            mp_StTypeRefCnt->MI_RefCount = 1 ;

            new(&mp_StTypeRefCnt->MO_TypeData)
                TypeData(ArTTypeArg1, ArTTypeArg2);
        }/*
        template<typename TTypeArg1, typename TTypeArg2>
            ZtCObjNew(TTypeArg1& ArTTypeArg1, TTypeArg2& ArTTypeArg2))*/

        ZtCObjNew(const ZtCObjNew& rhs)
        {
            mp_StTypeRefCnt = rhs.mp_StTypeRefCnt ;
          ++mp_StTypeRefCnt->MI_RefCount          ;
        }/*
        ZtCObjNew(const ZtCObjNew& rhs)*/

        ~ZtCObjNew()
        {
            if(--mp_StTypeRefCnt->MI_RefCount <= 0)
                this->ZCAllocator::FiniMem(mp_StTypeRefCnt);
        }/*
        ~ZtCObjNew()*/

        ZtCObjNew& operator=(const ZtCObjNew& rhs)
        {
            if(this==&rhs || mp_StTypeRefCnt==rhs.mp_StTypeRefCnt)
                { return *this; }
            /*++++++++++++++++++++++++++++++++++++++++++++++++++*/

                mp_StTypeRefCnt->MO_TypeData =
            rhs.mp_StTypeRefCnt->MO_TypeData ;

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

        ZtCObjNew& operator=(const TypeData& AR_TypeData)
        {
            if(&mp_StTypeRefCnt->MO_TypeData==&AR_TypeData) return *this;

            mp_StTypeRefCnt->MO_TypeData = AR_TypeData;     return *this;
        }/*
        ZtCObjNew& operator=(const TypeData& AR_TypeData)*/

        TypeData& operator* (){return  mp_StTypeRefCnt->MO_TypeData;}
        TypeData* operator->(){return &mp_StTypeRefCnt->MO_TypeData;}

        operator TypeData&  (){return  mp_StTypeRefCnt->MO_TypeData;}

        ZTypInt   GetRefCnt () const{return  mp_StTypeRefCnt->MI_RefCount;}
        TypeData* GetObjPtr () const{return &mp_StTypeRefCnt->MO_TypeData;}

    public :
    };/*
    template<   typename TType, typename TAllocClass=ZCAllocClass
            >
    class ZtCObjNew : public TAllocClass //////////////////////*/


#ifdef _DEBUG

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

    ■  멀티쓰레드 환경에서는 반드시 _REENTRANT 이 정의되어 있어야 한다. 이
        것을 체크하기 위해 쓰레드를 만드는 클래스가 있다면 생성자에서 아래
        함수를 호출해서 _REENTRANT 가 정의되어 있는지 확인한다.

        -- 2009-12-23 10:38:00

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

    inline void _DEBUG_REENTRANT_Check()
    {
        if(_REENTRANT_BOOL_<1)
        {
            std::fstream fileout("DEBUG.txt", std::ios::out | std::ios::app);

            fileout<<"◆◆ Error! : _REENTRANT is Not Defined In Multi-Thread"<<std::endl;
            fileout.close();

            ::exit(1);
        }/*
        if(_REENTRANT_BOOL_<1)*/
    }/*
    inline void _DEBUG_REENTRANT_Check()*/

    #define _DEBUG_REENTRANT_CHECK_  _DEBUG_REENTRANT_Check();

#else // !defined(_DEBUG)

    #define _DEBUG_REENTRANT_CHECK_

#endif // !defined(_DEBUG)


#if defined(_REENTRANT)


    class ZCExceptSmallLock : public ZCExceptBase
    {
    private:
        long   ml_ErrCode;
        string mo_ErrMSG ;
    public :

        ZCExceptSmallLock(long AL_ErrCode, const char* AP_ErrMSG)
        {
            ml_ErrCode=AL_ErrCode; //////////////

            if(AP_ErrMSG!=0) mo_ErrMSG=AP_ErrMSG;
        }/*
        ZCExceptSmallLock(long AL_ErrCode, const char* AP_ErrMSG)*/

        long          GetErrCode() const{return ml_ErrCode;}
        const string& GetErrMSG () const{return mo_ErrMSG  ;}

    public:
    };/*
    class ZCExceptSmallLock : public ZCExceptBase*/


#endif //defined(_REENTRANT)


#if defined(_REENTRANT) && defined(_WIN)


    /*//////////////////////////////////////////////////////
    
    ■  아래 클래스는 여러 자료구조에서 내부적으로 정적변수나
        정적 object 를 동기화하기 위해 사용한다.

        윈도우에서는 크리티컬 섹션을 쓰는 것이 좋으나
        
            BOOL TryEnterCriticalSection(LPCRITICAL_SECTION)
            
        함수가 제대로 지원되지 않고 있다.

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


    class ZCMutexSmallLock;


    class ZCMutexSmallInit
    {
    private:
        HANDLE mh_Mutex;
    public :

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

        Administrator@q381-2673 UCRT64 /e/my_CPP/ZCpp/ZCppMainTest
        # g++.exe -o ZtCArray_000_mw.exe   ZtCArray_000.cpp -I../
        In file included from ../ZCppMain/ZtCArray.H:7,
                         from ZtCArray_000.cpp:4:
        ../ZCppMain/ZMainHead.H:3115:21: error: ISO C++17 does not allow dynamic exception specifications
         3115 |         void Lock() throw(ZCExceptSmallLock&)

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

        void Lock() /*throw(ZCExceptSmallLock&)*/
        {
            long VL_ErrCode=0;

            if((VL_ErrCode = ::WaitForSingleObject(mh_Mutex, INFINITE))==WAIT_ABANDONED)
            {
                throw ZCExceptSmallLock(VL_ErrCode, "ZCMutexSmallInit::Lock()");
            }/*
            if((VL_ErrCode = ::WaitForSingleObject(mh_Mutex, INFINITE))==WAIT_ABANDONED)*/
        }/*
        void Lock() /*throw(ZCExceptSmallLock&)*/

        void UnLock()
        {
            ::ReleaseMutex(mh_Mutex);
        }/*
        void UnLock()*/

        ZCMutexSmallInit()
        {
            /*  MUTEX 를 신호 상태로 만들고 이 함수를 호출한 쓰레드가 MUTEX 를 소유하지 않게
                한다. 신호 상태라 함은 다른 쓰레드가 진입할 수 있는 상태를 말한다.        */

            mh_Mutex = ::CreateMutex(NULL, FALSE, NULL);
        }/*
        ZCMutexSmallInit()*/

        ~ZCMutexSmallInit()
        {
            ::CloseHandle(mh_Mutex);
        }/*
        ~ZCMutexSmallInit()*/

    public:
    };/*
    class ZCMutexSmallInit*/


    class ZCMutexSmallLock
    {
    private:
        ZCMutexSmallInit& mr_ZCMutexInit;
    public :

        ZCMutexSmallLock(ZCMutexSmallInit& ArZCMutexInit):mr_ZCMutexInit(ArZCMutexInit)
        {
            mr_ZCMutexInit.Lock();
        }/*
        ZCMutexSmallLock(ZCMutexSmallInit& ArZCMutexInit)*/

        ~ZCMutexSmallLock()
        {
            mr_ZCMutexInit.UnLock();
        }/*
        ~ZCMutexSmallLock()*/

    public:
    };/*
    class ZCMutexSmallLock*/



#elif defined(_REENTRANT) && defined(__unix__)


    // 유닉스(특히 리눅스) 상에서 _REENTRANT 이 정의되어 있으면
    // -lpthread 옵션을 잊지 말 것.


    class ZCMutexSmallLock;


    class ZCMutexSmallInit
    {
    private:
        ::pthread_mutex_t mo_Mutex;
    public :

        void Lock() throw(ZCExceptSmallLock&)
        {
            long VL_ErrCode=0;

            if((VL_ErrCode = ::pthread_mutex_lock(&mo_Mutex))!=0)
            {
                throw ZCExceptSmallLock(VL_ErrCode, "ZCMutexSmallInit::Lock()");
            }/*
            if((VL_ErrCode = ::pthread_mutex_lock(&mo_Mutex))!=0)*/
        }/*
        void Lock() throw(ZCExceptSmallLock&)*/

        void UnLock() throw(ZCExceptSmallLock&)
        {
            long VL_ErrCode=0;

            if((VL_ErrCode=::pthread_mutex_unlock(&mo_Mutex))!=0)
            {
                throw ZCExceptSmallLock(VL_ErrCode, "ZCMutexSmallInit::UnLock()");
            }/*
            if((VL_ErrCode=::pthread_mutex_unlock(&mo_Mutex))!=0)*/
        }/*
        void UnLock() throw(ZCExceptSmallLock&)*/

        ZCMutexSmallInit() throw(ZCExceptSmallLock&)
        {
            ::pthread_mutexattr_t VO_MutexAttr;

            ::pthread_mutexattr_init(&VO_MutexAttr);
            ::pthread_mutexattr_settype(&VO_MutexAttr, PTHREAD_MUTEX_RECURSIVE);

            long VL_ErrCode=0;

            if((VL_ErrCode = ::pthread_mutex_init(&mo_Mutex, &VO_MutexAttr))!=0)
            {
                throw ZCExceptSmallLock(VL_ErrCode, "ZCMutexSmallInit::ZCMutexSmallInit()");
            }/*
            if((VL_ErrCode = ::pthread_mutex_init(&mo_Mutex, &VO_MutexAttr))!=0)*/
        }/*
        ZCMutexSmallInit() throw(ZCExceptSmallLock&)*/

        ~ZCMutexSmallInit() throw(ZCExceptSmallLock&)
        {
            long VL_ErrCode=0;

            if((VL_ErrCode = ::pthread_mutex_destroy(&mo_Mutex))!=0)
            {
                throw ZCExceptSmallLock(VL_ErrCode, "ZCMutexSmallInit::~ZCMutexSmallInit()");
            }/*
            if((VL_ErrCode = ::pthread_mutex_destroy(&mo_Mutex))!=0)*/
        }/*
        ~ZCMutexSmallInit() throw(ZCExceptSmallLock&)*/

    public:
    };/*
    class ZCMutexSmallInit*/


    class ZCMutexSmallLock
    {
    private:
        ZCMutexSmallInit& mr_ZCMutexInit;
    public :

        ZCMutexSmallLock(ZCMutexSmallInit& ArZCMutexInit):mr_ZCMutexInit(ArZCMutexInit)
        {
            mr_ZCMutexInit.Lock();
        }/*
        ZCMutexSmallLock(ZCMutexSmallInit& ArZCMutexInit)*/

        ~ZCMutexSmallLock()
        {
            mr_ZCMutexInit.UnLock();
        }/*
        ~ZCMutexSmallLock()*/

    public:
    };/*
    class ZCMutexSmallLock*/


//    defined(_REENTRANT) && defined(__unix__)
#elif defined(_REENTRANT)


    // _REENTRANT 이 정의되어 있으면 -lpthread 옵션을 잊지 말 것.

    class ZCMutexSmallLock;


    class ZCMutexSmallInit
    {
    private:
        ::pthread_mutex_t mo_Mutex;
    public :

        void Lock() throw(ZCExceptSmallLock&)
        {
            long VL_ErrCode=0;

            if((VL_ErrCode=::pthread_mutex_lock(&mo_Mutex))!=0)
            {
                throw ZCExceptSmallLock(VL_ErrCode, "ZCMutexSmallInit::Lock()");
            }/*
            if((VL_ErrCode=::pthread_mutex_lock(&mo_Mutex))!=0)*/
        }/*
        void Lock() throw(ZCExceptSmallLock&)*/

        void UnLock() throw(ZCExceptSmallLock&)
        {
            long VL_ErrCode=0;

            if((VL_ErrCode=::pthread_mutex_unlock(&mo_Mutex))!=0)
            {
                throw ZCExceptSmallLock(VL_ErrCode, "ZCMutexSmallInit::UnLock()");
            }/*
            if((VL_ErrCode=::pthread_mutex_unlock(&mo_Mutex))!=0)*/
        }/*
        void UnLock() throw(ZCExceptSmallLock&)*/

        ZCMutexSmallInit() throw(ZCExceptSmallLock&)
        {
            ::pthread_mutexattr_t VO_MutexAttr;

            ::pthread_mutexattr_init(&VO_MutexAttr);
            ::pthread_mutexattr_settype(&VO_MutexAttr, PTHREAD_MUTEX_RECURSIVE);

            long VL_ErrCode=0;

            if((VL_ErrCode= ::pthread_mutex_init(&mo_Mutex, &VO_MutexAttr))!=0)
            {
                throw ZCExceptSmallLock(VL_ErrCode, "ZCMutexSmallInit::ZCMutexSmallInit()");
            }/*
            if((VL_ErrCode= ::pthread_mutex_init(&mo_Mutex, &VO_MutexAttr))!=0)*/
        }/*
        ZCMutexSmallInit() throw(ZCExceptSmallLock&)*/

        ~ZCMutexSmallInit() throw(ZCExceptSmallLock&)
        {
            long VL_ErrCode=0;

            if((VL_ErrCode= ::pthread_mutex_destroy(&mo_Mutex))!=0)
            {
                throw ZCExceptSmallLock(VL_ErrCode, "ZCMutexSmallInit::~ZCMutexSmallInit()");
            }/*
            if((VL_ErrCode= ::pthread_mutex_destroy(&mo_Mutex))!=0)*/
        }/*
        ~ZCMutexSmallInit() throw(ZCExceptSmallLock&)*/

    public:
    };/*
    class ZCMutexSmallInit*/


    class ZCMutexSmallLock
    {
    private:
        ZCMutexSmallInit& mr_ZCMutexInit;
    public :

        ZCMutexSmallLock(ZCMutexSmallInit& ArZCMutexInit):mr_ZCMutexInit(ArZCMutexInit)
        {
            mr_ZCMutexInit.Lock();
        }/*
        ZCMutexSmallLock(ZCMutexSmallInit& ArZCMutexInit)*/

        ~ZCMutexSmallLock()
        {
            mr_ZCMutexInit.UnLock();
        }/*
        ~ZCMutexSmallLock()*/

    public :
    };/*
    class ZCMutexSmallLock*/


#endif //defined(_REENTRANT)



#if defined(_DEBUG) && defined(_REENTRANT)

    class ZCSyncLog
    {
    private  :
        typedef ZCMutexSmallInit ZCSync;
    protected:
        static ZCSync& GetCSync()
        {
            static ZCSync SO_CSyncLog; return SO_CSyncLog;
        }/*
        static ZCSync& GetCSync()*/
    public   :
        ZCSyncLog (){GetCSync().Lock  ();}
        ~ZCSyncLog(){GetCSync().UnLock();}
    public   :
    };/*
    class ZCSyncLog*/

#endif // defined(_DEBUG) && defined(_REENTRANT)



#ifdef _DEBUG


    static inline void ZfWriteError(const char* ApcErrorStr)
    {
        std::fstream fileout(
            "DEBUG.txt", std::ios::out | std::ios::app);

        fileout<<ApcErrorStr<<std::endl;
        fileout.close();

        ::exit(1);
    }/*
    static inline void ZfWriteError(const char* ApcErrorStr)*/


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

    ■  이 object 를 멤버로 가진 object 는 container 외부에 만들어질 수 없다.
        container 의 링크나 노드를 설계할 때 그 링크나 노드가(DEBUG 모드에서)
        Stack 에 만들어지는지 혹은 container 외부에서 new 로 만들어지는지를
        체크할 때 유용하다. container 의 링크는 container 내부에서만 new,
        delete 되어야 한다.

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

    class ZCCheckAlloc
    {
    public :
        class ZCAllowAlloc;  friend class ZCAllowAlloc;
    private:

        static bool& GetAllowAllocBool()
        {
            static bool SB_AllowAlloc=false; return SB_AllowAlloc;
        }/*
        static bool& GetAllowAllocBool()*/

  /*private:*/
    public :

        ZCCheckAlloc()
        {
            if(GetAllowAllocBool()==false)
            {
                cout<<endl<<"Warning! Unallowed Object Memory Allocation!"<<endl<<endl;
            }/*
            if(GetAllowAllocBool()==false)*/
        }/*
        ZCCheckAlloc()*/

        static bool IsAllowAlloc()
        {
            return GetAllowAllocBool();
        }/*
        static bool IsAllowAlloc()*/

  /*public:*/
    public:


        class ZCAllowAlloc
        {
        private:

            bool mb_AllowAlready ;

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

            ■  위 멤버변수를 설계하면 ZCAllowAlloc object 멤버함수가
                중첩호출될 경우, 가장 처음에 호출하는 함수가

                    ZCCheckAlloc::GetAllowAllocBool()=false;

                이 부분을 수행하게 된다. 결국 중첩호출 도중에
                ZCCheckAlloc::GetAllowAllocBool() 은 항상 true 가 된다.

            ■  --

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

      /*private:*/
        public :

            ZCAllowAlloc()
            {
                mb_AllowAlready=ZCCheckAlloc::GetAllowAllocBool();

                ZCCheckAlloc::GetAllowAllocBool()=true; //////////
            }/*
            ZCAllowAlloc()*/

            ~ZCAllowAlloc()
            {
                if(mb_AllowAlready==false)
                    ZCCheckAlloc::GetAllowAllocBool()=false;
            }/*
            ZCAllowAlloc()*/

        public:
        };/*
        class ZCAllowAlloc()*/


    public:
    };/*
    class ZCCheckAlloc*/


    static ZTypIntL SI_Count_DEBUG=0;


#endif //_DEBUG


    namespace ZNsConst
    {
    #if defined(_WIN)

        #define __DIR_DELIMITERS__ "\\"
        #define __DIR_DELIMITER__  '\\'

        ZTypCPCCh CPC_DirDelimiter="\\";
        ZTypCChar CC_DirDelimiter ='\\';

        ZTypCPCCh CPC_Delm        ="\\";
        ZTypCChar CC_Delm         ='\\';

    #else //!(defined(_WIN)

        #define __DIR_DELIMITERS__ "/"
        #define __DIR_DELIMITER__  '/'

        ZTypCPCCh CPC_DirDelimiter="/" ;
        ZTypCChar CC_DirDelimiter ='/' ;

        ZTypCPCCh CPC_Delm        ="/" ;
        ZTypCChar CC_Delm         ='/' ;

    #endif //!(defined(_WIN)
    }/*
    namespace ZNsConst*/



    template<typename TStringData> TStringData& ZftConvertXhtml(TStringData& ARRoCString)
    {
        /*  데이타를 그대로 클라이언트에 전송하면, HTML 태그와
            혼동될 수 있는데, 이를 방지하기 위해 적절히 인코딩한다.
        */
        return ARRoCString.
            Replace("&" ,"&amp;"  ). Replace("<" ,"&lt;"  ).
            Replace(">" ,"&gt;"   ). Replace(" " ,"&nbsp;").
            Replace("\n","<br />" );
    }/*
    template<typename TStringData> TStringData& ConvertXhtml(TStringData& ARRoCString) */


    template<typename TStringData> TStringData& ZftMakeXmlAttEnc(TStringData& ARRoCStringData)
    {
        return ARRoCStringData.
            Replace("&" , "&amp;" ).Replace("\r", "&#xA;" ).
            Replace("\n", "&#xD;" ).Replace("\t", "&#x9;" ).
            Replace("\"", "&quot;").Replace(">" , "&gt;"  ).Replace("<", "&lt;");
    }/*
    template<typename TStringData> TStringData& ZftMakeXmlAttEnc(TStringData& ARRoCStringData)*/

    template<typename TStringData> TStringData& ZftMakeXmlAttDec(TStringData& ARRoCStringData)
    {
        return ARRoCStringData.
            Replace("&#xA;" ,"\r" ). Replace("&#xD;" ,"\n").
            Replace("&#x9;" ,"\t" ). Replace("&quot;","\"").
            Replace("&gt;"  ,">"  ). Replace("&lt;"  ,"<" ). Replace("&amp;" ,"&"    );
    }/*
    template<typename TStringData> TStringData& ZftMakeXmlAttDec(TStringData& ARRoCStringData)*/



    template<typename TString, typename TObject>
        TString& ZftMakeStr(TString& ARR_SaveCStr, TObject AO_Object)
            { return ARR_SaveCStr; }
    ////////////////////////////////////////////


    template<> string& ZftMakeStr(string& ARR_SaveCStr, const string& AR_DataCStr)
    {
        ARR_SaveCStr.append(AR_DataCStr);  return ARR_SaveCStr;
    }/*
    template<> string& ZftMakeStr(string& ARR_SaveCStr, const string& AR_DataCStr)*/

    template<> string& ZftMakeStr(string& ARR_SaveCStr, long AL_Long)
    {
        ZTycInt  CI_BuffSize   = 31         ;
        ZTypChar VCA_BuffParam[CI_BuffSize] ;

        ZTypInt  VI_ResultSize =
            ::sprintf(VCA_BuffParam, "%ld", AL_Long);

        ARR_SaveCStr.append
            (VCA_BuffParam, VI_ResultSize);

        return ARR_SaveCStr;
    }/*
    template<> string& ZftMakeStr(string& ARR_SaveCStr, long AL_Long)*/

    template<> string& ZftMakeStr(string& ARR_SaveCStr, double AD_Double)
    {
        ZTycInt  CI_BuffSize=51            ;
        ZTypChar VCA_BuffParam[CI_BuffSize];

        ZTypInt  VI_ResultSize = ::sprintf
            (
                VCA_BuffParam, "%f", AD_Double
            );
        /////////////////////////////

        ARR_SaveCStr.append
             (VCA_BuffParam, VI_ResultSize);

        return ARR_SaveCStr;
    }/*
    template<> string& ZftMakeStr(string& ARR_SaveCStr, double AD_Double)*/

    template<> string& ZftMakeStr(string& ARR_SaveCStr, bool AB_Bool)
    {
        if   (AB_Bool)
              ARR_SaveCStr.append("true" );
        else  ARR_SaveCStr.append("false");

        return ARR_SaveCStr;
    }/*
    template<> string& ZftMakeStr(string& ARR_SaveCStr, bool AB_Bool)*/



    // class ZtCBaseList : circular double linked list

    template //////////////////////////////////////////////////////////////////
        <
            typename TType ,
            typename TTypArgu   = const TType&    ,
            typename TTypeAlloc = ZCAllocator     ,
            typename TTypSize   = ZTypLong        ,
            typename TMoveObj   = ZNsMain::
                ZtCMoveObj<TType, TTypArgu, true> ,
            typename TTypeCRTP  = ZNsType::ZtCTypeCRTP<ZCEmpty, false>
        >
    class ZtCBaseList /*#####################################################*/
    {
    public:
        class ZCLink;
    public:
        typedef TType       TypeData    ;
        typedef TTypArgu    TypeArg     ;
        typedef TTypeAlloc  TypeAlloc   ;
        typedef TTypSize    TypeSize    ;
        typedef TMoveObj    TypeMoveObj ;
        typedef ZCLink*     IterEasy    ; // 가장 대표적으로 쓰일 수 있는 반복자.
        typedef ZCLink*     iterator    ;
    public:

        typedef ZNsType::ZtCTypeNowCRTP ///////////////////////////////////////
            <
                ZtCBaseList, typename TTypeCRTP::TypeData, TTypeCRTP::ZEUseCRTP
            >
        ZCTypeNowCRTP ; ///////////////////////////////////////////////////////

        typedef typename ZCTypeNowCRTP::TypeData TypeChild;

    public :

        class ZCLink : public TypeAlloc
        {
        public :
            friend class ZtCBaseList;
        private:
            TypeData  mo_DataObjt ;
            ZCLink*   mp_NextLink ;
            ZCLink*   mp_PrevLink ;
        private:
        /*++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/
                ZCLink* GetNextPtr()     {return mp_NextLink;}
                ZCLink* GetPrevPtr()     {return mp_PrevLink;}
          const ZCLink* GetNextPtr()const{return mp_NextLink;}
          const ZCLink* GetPrevPtr()const{return mp_PrevLink;}
        /*++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/
        private:

            static void JoinLink(ZCLink* AP_PrevLink, ZCLink* AP_NextLink)
            {
                AP_PrevLink->mp_NextLink=AP_NextLink;
                AP_NextLink->mp_PrevLink=AP_PrevLink;
            }/*
            static void JoinLink(ZCLink* AP_PrevLink, ZCLink* AP_NextLink)*/

            static void MakeRing(ZCLink* AP_HeadLink, ZCLink* AP_TailLink)
            {
                AP_HeadLink->mp_PrevLink=AP_TailLink;
                AP_TailLink->mp_NextLink=AP_HeadLink;
            }/*
            static void MakeRing(ZCLink* AP_HeadLink, ZCLink* AP_TailLink)*/

        public:

            ZCLink()
            {
                mp_NextLink = mp_PrevLink = 0;
            }/*
            ZCLink()*/

            ZCLink(const ZCLink& rhs)
            {
                mo_DataObjt = rhs.mo_DataObjt ;
                mp_NextLink = 0               ;
                mp_PrevLink = 0               ;
            }/*
            ZCLink(const ZCLink& rhs)*/

            ZCLink(TypeArg AR_Data)
            {
                mo_DataObjt = AR_Data ;
                mp_NextLink = 0       ;
                mp_PrevLink = 0       ;
            }/*
            ZCLink(const ZCLink& rhs)*/

            ZCLink& operator=(const ZCLink& rhs)
            {
                mo_DataObjt = rhs.mo_DataObjt;  return *this;
            }/*
            ZCLink& operator=(const ZCLink& rhs)*/


            ZCLink* GetNextPrevPtr(TypeSize AL_FarNum)
            {
                ZCLink* VP_TmpLink=this;

                if(AL_FarNum>=0)
                    { while(--AL_FarNum>=0) VP_TmpLink=VP_TmpLink->mp_NextLink; }
                else{ while(++AL_FarNum<=0) VP_TmpLink=VP_TmpLink->mp_PrevLink; }

                return VP_TmpLink;
            }/*
            ZCLink* GetNextPrevPtr(TypeSize AL_FarNum)*/

            const ZCLink* GetNextPrevPtr(TypeSize AL_FarNum) const
            {
                ZCLink* VP_TmpLink=const_cast<ZCLink*>(this);

                if(AL_FarNum>=0)
                    { while(--AL_FarNum>=0) VP_TmpLink=VP_TmpLink->mp_NextLink; }
                else{ while(++AL_FarNum<=0) VP_TmpLink=VP_TmpLink->mp_PrevLink; }

                return VP_TmpLink;
            }/*
            const ZCLink* GetNextPrevPtr(TypeSize AL_FarNum) const*/


            operator TypeData&    (){return mo_DataObjt;}
            operator TypeData     (){return mo_DataObjt;}
            TypeData&    GetData  (){return mo_DataObjt;}
            TypeData&    operator*(){return mo_DataObjt;}

            operator const TypeData&    () const{return mo_DataObjt;}
            const    TypeData& GetData  () const{return mo_DataObjt;}
            const    TypeData& operator*() const{return mo_DataObjt;}


            ZCLink& operator+(TypeSize AL_Distance)
              { return *GetNextPrevPtr( AL_Distance); }
            ZCLink& operator-(TypeSize AL_Distance)
              { return *GetNextPrevPtr(-AL_Distance); }

            const ZCLink& operator+(TypeSize AL_Distance) const
              { return *GetNextPrevPtr( AL_Distance); }
            const ZCLink& operator-(TypeSize AL_Distance) const
              { return *GetNextPrevPtr(-AL_Distance); }

        public:
        };/*
        class ZCLink*/


    public  :
    private :
        ZCLink*   mp_HeadLink ;
        ZCLink*   mp_TailLink ;
        TypeSize  ml_LinkSize ;
    private :

        TypeChild& GetChildObj()
        {
            return *static_cast<TypeChild*>(this);
        }/*
        TypeChild& GetChildObj()*/

    protected:

        ZCLink* NewLink()
        {
            return new ZCLink;
        }/*
        ZCLink* NewLink()*/

        ZCLink* NewLink(TypeArg AO_ArgData)
        {
            return new ZCLink(AO_ArgData);
        }/*
        ZCLink* NewLink(TypeArg AO_ArgData)*/

        void NewLink ////////////////////////////////////////
            (
                TypeSize AL_NeedCnt   ,
                ZCLink*& APR_HeadLink ,
                ZCLink*& APR_TailLink
            )
        /////////////////////////////////////////////////////
        {
            APR_HeadLink = new ZCLink;

            ZCLink* VP_MakeLink = 0           ;
            ZCLink* VP_TailLink = APR_HeadLink;

            while(--AL_NeedCnt>0) // AL_NeedCnt - 1 번 순환
            {
                // AL_NeedCnt - 1 번 순환

                VP_MakeLink = new ZCLink;

                ZCLink::JoinLink
                    (VP_TailLink, VP_MakeLink);
                VP_TailLink = VP_MakeLink ;
            }/*
            while(--AL_NeedCnt>0)*/

            APR_TailLink = VP_TailLink;
        }/*
        void NewLink ////////////////////////////////////////
            (
                TypeSize AL_NeedCnt   ,
                ZCLink*& APR_HeadLink ,
                ZCLink*& APR_TailLink
            )
        ///////////////////////////////////////////////////*/


        void NewLinkCopy   //////////////////////////////////
            (
                ZCLink*  AP_LinkOrgin, TypeSize AL_FarNum   ,
                ZCLink*& APR_HeadCopy, ZCLink*& APR_TailCopy
            )
        /////////////////////////////////////////////////////
        {
            // 총 AL_FarNum+1 개의 링크가 만들어짊

            ZCLink* VP_MakeLink  = 0  ;
            ZCLink* VP_TailLink  = 0  ;

            VP_TailLink  = VP_MakeLink =
                new ZCLink(**AP_LinkOrgin) ;

            APR_HeadCopy = VP_MakeLink;

            while(--AL_FarNum >= 0)
            {
                AP_LinkOrgin= AP_LinkOrgin->GetNextPtr();
                VP_MakeLink = new ZCLink(**AP_LinkOrgin);

                ZCLink::JoinLink
                    (VP_TailLink, VP_MakeLink);

                VP_TailLink = VP_MakeLink;
            }/*
            while(--AL_FarNum >= 0)*/

            APR_TailCopy=VP_TailLink;
        }/*
        void NewLinkCopy   //////////////////////////////////
            (
                ZCLink*  AP_LinkOrgin, TypeSize AL_FarNum   ,
                ZCLink*& APR_HeadCopy, ZCLink*& APR_TailCopy
            )
        ///////////////////////////////////////////////////*/


        void DelLink(ZCLink* AP_DelLink)
        {
            delete AP_DelLink;
        }/*
        void DelLink(ZCLink* AP_DelLink)*/

        void DelLink //////////////////////////////////////////
            (
                TypeSize  AL_CutCnt ,
                ZCLink*   AP_CutHead,
                ZCLink*   AP_CutTail
            )
        ///////////////////////////////////////////////////////
        {
            ZCLink* VP_DelLink = AP_CutHead;

            __for0(TypeSize, i, AL_CutCnt)
            {
                AP_CutHead = AP_CutHead->GetNextPtr() ;

                delete VP_DelLink;  VP_DelLink=AP_CutHead;
            }/*
            __for0(TypeSize, i, AL_CutCnt)*/
        }
        ///////////////////////////////////////////////////////

  /*protected:*/
    private  :

        _VT_ ZCLink* SendFreeOut()
        {
            if(TTypeCRTP::ZEUseCRTP<1) return NewLink();

            return GetChildObj().SendFreeOut();
        }/*
        _VT_ ZCLink* SendFreeOut()*/

        _VT_ ZCLink* SendFreeOut(TypeArg AO_ArgData)
        {
            if(TTypeCRTP::ZEUseCRTP<1)
                { return NewLink(AO_ArgData); }

            return GetChildObj().SendFreeOut(AO_ArgData);
        }/*
        _VT_ ZCLink* SendFreeOut(TypeArg AO_ArgData)*/

        _VT_ void SendFreeOut
            (TypeSize AL_NeedCnt, ZCLink*& APR_HeadLink, ZCLink*& APR_TailLink)
        {
            if(TTypeCRTP::ZEUseCRTP<1)
            {
                NewLink(AL_NeedCnt, APR_HeadLink, APR_TailLink); return;
            }/*
            if(TTypeCRTP::ZEUseCRTP<1)*/

            return GetChildObj().SendFreeOut
                (AL_NeedCnt, RR(APR_HeadLink), RR(APR_TailLink));
        }/*
        _VT_ void SendFreeOut
            (TypeSize AL_NeedCnt, ZCLink*& APR_HeadLink, ZCLink*& APR_TailLink)
        */

        _VT_ void SendFreeOutCopy /*///////////////////////*/
            (
                ZCLink*  AP_LinkOrgin, TypeSize AL_FarNum   ,
                ZCLink*& APR_HeadCopy, ZCLink*& APR_TailCopy
            )
        /////////////////////////////////////////////////////
        {
            // 총 AL_FarNum+1 개의 링크가 만들어짊

            if(TTypeCRTP::ZEUseCRTP<1)
            {
                NewLinkCopy(AP_LinkOrgin, AL_FarNum, APR_HeadCopy, APR_TailCopy); return;
            }/*
            if(TTypeCRTP::ZEUseCRTP<1)*/

            return GetChildObj().SendFreeOutCopy
                (AP_LinkOrgin, AL_FarNum, RR(APR_HeadCopy), RR(APR_TailCopy));
        }/*
        _VT_ void SendFreeOutCopy   /////////////////////////
            (
                ZCLink*  AP_LinkOrgin, TypeSize AL_FarNum   ,
                ZCLink*& APR_HeadCopy, ZCLink*& APR_TailCopy
            )
        ///////////////////////////////////////////////////*/


        _VT_ void RecvFreeIn(ZCLink* AP_DelLink)
        {
            if(TTypeCRTP::ZEUseCRTP<1)
                { DelLink(AP_DelLink);  return; }

            GetChildObj().RecvFreeIn(AP_DelLink);
        }/*
        _VT_ void RecvFreeIn(ZCLink* AP_DelLink)*/

        _VT_ void RecvFreeIn //////////////////////////////////
            (
                TypeSize  AL_CutCnt ,
                ZCLink*   AP_CutHead,
                ZCLink*   AP_CutTail
            )
        ///////////////////////////////////////////////////////
        {
            if(TTypeCRTP::ZEUseCRTP<1)
            {
                DelLink
                    (AL_CutCnt, AP_CutHead, AP_CutTail);
                return;
            }/*
            if(TTypeCRTP::ZEUseCRTP<1)*/

            GetChildObj().RecvFreeIn(AL_CutCnt, AP_CutHead, AP_CutTail);
        }/*
        _VT_ void RecvFreeIn //////////////////////////////////
            (
                TypeSize  AL_CutCnt ,
                ZCLink*   AP_CutHead,
                ZCLink*   AP_CutTail
            )
        /////////////////////////////////////////////////////*/

  /*private :*/
    private :

        ZCLink* AddTailLink(ZCLink* AP_NewLink)
        {
            if(ml_LinkSize<1)
            {
                mp_HeadLink = AP_NewLink;
                mp_TailLink = AP_NewLink;

                ZCLink::MakeRing
                    ( mp_HeadLink, mp_TailLink ) ;

                ml_LinkSize= 1;  return AP_NewLink;
            }/*
            if(ml_LinkSize<1)*/

            ZCLink::JoinLink(mp_TailLink, AP_NewLink) ;
            ZCLink::MakeRing(mp_HeadLink, AP_NewLink) ;

            mp_TailLink = AP_NewLink;  ++ml_LinkSize  ;

            return AP_NewLink; /*::::::::::::::::::::*/
        }/*
        ZCLink* AddTailLink(ZCLink* AP_CLink)*/

        ZCLink* AddHeadLink(ZCLink* AP_NewLink)
        {
            if(ml_LinkSize<1)
            {
                mp_HeadLink = AP_NewLink;
                mp_TailLink = AP_NewLink;

                ZCLink::MakeRing
                    ( mp_HeadLink, mp_TailLink ) ;

                ml_LinkSize= 1;  return AP_NewLink;
            }/*
            if(ml_LinkSize<1)*/

            ZCLink::JoinLink(AP_NewLink, mp_HeadLink) ;
            ZCLink::MakeRing(AP_NewLink, mp_TailLink) ;

            mp_HeadLink = AP_NewLink;  ++ml_LinkSize  ;

            return AP_NewLink; /*::::::::::::::::::::*/
        }/*
        ZCLink* AddHeadLink(ZCLink* AP_CLink)*/


  /*private :*/
    public  :

        ZtCBaseList()
        {
            mp_HeadLink = 0 ;
            mp_TailLink = 0 ;
            ml_LinkSize = 0 ;
        }/*
        ZtCBaseList()*/

        ZtCBaseList(const ZtCBaseList& rhs)
        {
            mp_HeadLink = 0 ;
            mp_TailLink = 0 ;
            ml_LinkSize = 0 ;

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

        ~ZtCBaseList()
        {
            DeleteAll();
        }/*
        ~ZtCBaseList()*/


        ZtCBaseList& operator=(const ZtCBaseList& rhs)
        {
            if(this==&rhs) return *this;

            if(rhs.size()<1)
                { this->DeleteAll(); return *this; }

            TypeSize VL_MinusSize = this->size() - rhs.size() ;

            if     (VL_MinusSize>0)
            {
                RecvFreeIn ////////////////////////////////////////
                    (
                        VL_MinusSize,
                        mp_HeadLink ,
                        mp_HeadLink->GetNextPrevPtr(VL_MinusSize-1)
                    );
                ///////////////////////////////////////////////////

                ml_LinkSize -= VL_MinusSize;
            }
            else if(VL_MinusSize<0)
            {
                ZCLink* VP_HeadLink=0;
                ZCLink* VP_TailLink=0;

                SendFreeOut ////////////////////////////////////////
                    (
                       -VL_MinusSize    ,
                        RR(VP_HeadLink) ,
                        RR(VP_TailLink)
                    );
                ///////////////////////////////////////////////////

                if(ml_LinkSize>0)
                {
                    ZCLink::JoinLink(mp_TailLink, VP_HeadLink);
                    ZCLink::MakeRing(mp_HeadLink, VP_TailLink);

                    mp_TailLink = VP_TailLink ;
                }
                else
                {
                    mp_HeadLink = VP_HeadLink ;
                    mp_TailLink = VP_TailLink ;

                    ZCLink::MakeRing(mp_HeadLink, VP_TailLink);
                }/*
                else*/

                ml_LinkSize += (-VL_MinusSize);
            }/*
            else if(VL_MinusSize<0)*/


            ZCLink* VP_RhsLink = rhs.mp_HeadLink ;
            ZCLink* VP_LhsLink =     mp_HeadLink ;

            __for0(TypeSize, i, rhs.size())
            {
                **VP_LhsLink = **VP_RhsLink ;

                VP_RhsLink = VP_RhsLink->mp_NextLink;
                VP_LhsLink = VP_LhsLink->mp_NextLink;
            }/*
            __for0(TypeSize, i, rhs.size())*/

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


        void DeleteAll()
        {
            if(ml_LinkSize<1) return;

            RecvFreeIn
                (ml_LinkSize, mp_HeadLink, mp_TailLink);

            mp_HeadLink =0 ;
            mp_TailLink =0 ;
            ml_LinkSize =0 ;
        }/*
        void DeleteAll()*/


        TypeData& AddHead()
            { return **AddHeadLink(SendFreeOut()); }
        TypeData& AddTail()
            { return **AddTailLink(SendFreeOut()); }


        TypeData& AddHead(TypeArg AO_ArgData) /*########################*/
        {
        #if(_CODE_NEW_)
            if(TypeMoveObj::ZEUseMoveObj>0) ////////////////////
            {
                ZCLink* VP_NewNode = SendFreeOut(AO_ArgData);

                TypeMoveObj::Exec(**VP_NewNode, AO_ArgData);

                return AddHeadLink(VP_NewNode)->mo_DataObjt;
            }
            ////////////////////////////////////////////////////
        #endif
            return AddHeadLink(new ZCLink(AO_ArgData))->mo_DataObjt;
        }/*
        TypeData& AddHead(TypeArg AO_ArgData) ##########################*/

        TypeData& AddTail(TypeArg AO_ArgData) /*########################*/
        {
        #if(_CODE_NEW_)
            if(TypeMoveObj::ZEUseMoveObj>0) ////////////////////
            {
                ZCLink* VP_NewNode = SendFreeOut(AO_ArgData);

                TypeMoveObj::Exec(*VP_NewNode, AO_ArgData);

                return AddTailLink(VP_NewNode)->mo_DataObjt;
            }
            ////////////////////////////////////////////////////
        #endif
            return AddTailLink(new ZCLink(AO_ArgData))->mo_DataObjt;
        }/*
        TypeData& AddTail(TypeArg AO_ArgData) ##########################*/


        ZtCBaseList& AddHead(ZtCBaseList& rhs)
        {
            if(this == &rhs ) return *this;
            if(rhs.size()<1 ) return *this;

            ZtCBaseList VO_TempList(rhs);

            return JoinHead(VO_TempList);
        }/*
        ZtCBaseList& AddHead(ZtCBaseList& rhs)*/

        ZtCBaseList& AddTail(ZtCBaseList& rhs)
        {
            if(this == &rhs ) return *this;
            if(rhs.size()<1 ) return *this;

            ZtCBaseList VO_TempList(rhs);

            return JoinTail(VO_TempList);
        }/*
        ZtCBaseList& AddTail(ZtCBaseList& rhs)*/


        void DeleteHead()
        {
            if(ml_LinkSize<1) return;

            ZCLink* VP_TempLink = mp_HeadLink ;
                    mp_HeadLink = mp_HeadLink->mp_NextLink ;

            RecvFreeIn(VP_TempLink);

            if(--ml_LinkSize<1)
            {
                mp_HeadLink = mp_TailLink =0; return;
            }/*
            if(--ml_LinkSize<1)*/

            ZCLink::MakeRing(mp_HeadLink, mp_TailLink);
        }/*
        void DeleteHead()*/


        void DeleteTail()
        {
            if(ml_LinkSize<1) return;

            ZCLink* VP_TempLink = mp_TailLink ;
                    mp_TailLink = mp_TailLink->mp_PrevLink ;

            RecvFreeIn(VP_TempLink);

            if(--ml_LinkSize<1)
            {
                mp_HeadLink = mp_TailLink =0;  return;
            }/*
            if(--ml_LinkSize<1)*/

            ZCLink::MakeRing(mp_HeadLink, mp_TailLink);
        }/*
        void DeleteTail()*/


        void DeleteHead(TTypSize AL_DelSize)
        {
            // AL_DelSize 개의 링크를 앞 부분에서 삭제

            if(ml_LinkSize<1 || AL_DelSize<1){ return; }

            if(AL_DelSize > ml_LinkSize){ AL_DelSize=ml_LinkSize; }

            if(AL_DelSize==ml_LinkSize)
            {
                RecvFreeIn
                    (ml_LinkSize, mp_HeadLink, mp_TailLink);
                mp_HeadLink=0 ;
                mp_TailLink=0 ;
                ml_LinkSize=0 ;

                return;
            }/*
            if(AL_DelSize==ml_LinkSize)*/

            ZCLink* VP_NewHead =
                mp_HeadLink->GetNextPrevPtr( AL_DelSize ) ;
            RecvFreeIn
                (AL_DelSize, mp_HeadLink, VP_NewHead->mp_PrevLink);

            mp_HeadLink  = VP_NewHead   ;
            ml_LinkSize -= AL_DelSize   ;

            ZCLink::MakeRing(mp_HeadLink, mp_TailLink);
        }/*
        void DeleteHead(TTypSize AL_DelSize)*/


        void DeleteTail(TTypSize AL_DelSize)
        {
            if(ml_LinkSize==0 || AL_DelSize<1){ return; }

            if(AL_DelSize> ml_LinkSize){ AL_DelSize=ml_LinkSize; }

            if(AL_DelSize==ml_LinkSize)
            {
                RecvFreeIn
                    (ml_LinkSize, mp_HeadLink, mp_TailLink);
                mp_HeadLink=0 ;
                mp_TailLink=0 ;
                ml_LinkSize=0 ;

                return;
            }/*
            if(AL_DelSize==ml_LinkSize)*/

            ZCLink* VP_NewTail =
                mp_TailLink->GetNextPrevPtr( -AL_DelSize ) ;
            RecvFreeIn
                (AL_DelSize, VP_NewTail->mp_NextLink, mp_TailLink);

            mp_TailLink  = VP_NewTail ;
            ml_LinkSize -= AL_DelSize ;

            ZCLink::MakeRing(mp_HeadLink, mp_TailLink);
        }/*
        void DeleteTail(TTypSize AL_DelSize)*/


        ZtCBaseList& JoinAfter(ZtCBaseList& rhs, ZCLink* AP_StdLink)
        {
            // AP_StdLink 의 뒤에 rhs 를 삽입.

            if(rhs.ml_LinkSize<1) return *this;

            if(AP_StdLink==0) // 맨 앞에 삽입
            {
                if(ml_LinkSize<1)
                {
                    mp_HeadLink = rhs.mp_HeadLink ;
                    mp_TailLink = rhs.mp_TailLink ;
                    ml_LinkSize = rhs.ml_LinkSize ;
                }
                else // ml_LinkSize>=1
                {
                    ZCLink::JoinLink( rhs.mp_TailLink, mp_HeadLink );
                    ZCLink::MakeRing( rhs.mp_HeadLink, mp_TailLink );

                    mp_HeadLink = rhs.mp_HeadLink ;
                    ml_LinkSize = rhs.ml_LinkSize ;
                }/*
                else // ml_LinkSize>=1*/

                ml_LinkSize += rhs.ml_LinkSize;

                rhs.mp_HeadLink = 0 ;
                rhs.mp_TailLink = 0 ;
                rhs.ml_LinkSize = 0 ;

                return *this;
            }/*
            if(AP_StdLink==0)*/


            ZCLink* VP_StdNext=AP_StdLink->mp_NextLink;

            ZCLink::JoinLink(AP_StdLink     , rhs.mp_HeadLink );
            ZCLink::JoinLink(rhs.mp_TailLink, VP_StdNext      );

            if(AP_StdLink==mp_TailLink)
                { mp_TailLink=rhs.mp_TailLink; }

            rhs.mp_HeadLink =0 ;
            rhs.mp_TailLink =0 ;
            rhs.ml_LinkSize =0 ;

            ml_LinkSize += rhs.ml_LinkSize;  return *this;
        }/*
        ZtCBaseList& JoinAfter(ZtCBaseList& rhs, ZCLink* AP_StdLink)*/


        ZtCBaseList& JoinBefore(ZtCBaseList& rhs, ZCLink* AP_StdLink)
        {
            // AP_StdLink 의 앞에 rhs 를 삽입.

            if(rhs.size()<1) return *this;

            if(AP_StdLink==0) // 맨 뒤에 삽입
            {
                if(ml_LinkSize<1)
                {
                    mp_HeadLink = rhs.mp_HeadLink ;
                    mp_TailLink = rhs.mp_TailLink ;
                    ml_LinkSize = rhs.ml_LinkSize ;
                }
                else // ml_LinkSize>=1
                {
                    ZCLink::JoinLink(mp_TailLink, rhs.mp_HeadLink );
                    ZCLink::MakeRing(mp_HeadLink, rhs.mp_TailLink );

                    mp_TailLink  = rhs.mp_TailLink ;
                    ml_LinkSize += rhs.ml_LinkSize ;
                }/*
                else // ml_LinkSize>=1*/

                rhs.mp_HeadLink=0;
                rhs.mp_TailLink=0;
                rhs.ml_LinkSize=0;

                ml_LinkSize += rhs.ml_LinkSize;  return *this;
            }/*
            if(AP_StdLink==0)*/


            ZCLink* VP_StdPrev = AP_StdLink->mp_PrevLink;

            ZCLink::JoinLink(    VP_StdPrev , rhs.mp_HeadLink );
            ZCLink::JoinLink(rhs.mp_TailLink,     AP_StdLink  );

            if(AP_StdLink==mp_HeadLink)
              { mp_HeadLink = rhs.mp_HeadLink; }

            rhs.mp_HeadLink =0 ;
            rhs.mp_TailLink =0 ;
            rhs.ml_LinkSize =0 ;

            ml_LinkSize += rhs.ml_LinkSize;  return *this;
        }/*
        ZtCBaseList& JoinBefore(ZtCBaseList& rhs, ZCLink* AP_StdLink)*/


        ZtCBaseList& JoinHead(ZtCBaseList& rhs)
          { if(this==&rhs) return *this;  return JoinAfter (rhs, 0); }
        ZtCBaseList& JoinTail(ZtCBaseList& rhs)
          { if(this==&rhs) return *this;  return JoinBefore(rhs, 0); }


        TypeData& GetHeadData(){return mp_HeadLink->mo_DataObjt;}
        TypeData& GetTailData(){return mp_TailLink->mo_DataObjt;}

        const TypeData& GetHeadData() const{return mp_HeadLink->mo_DataObjt;}
        const TypeData& GetTailData() const{return mp_TailLink->mo_DataObjt;}

        operator TypeData&() { return AddTail() ; }


        TypeSize size()    const{ return ml_LinkSize; }
        TypeSize GetSize() const{ return ml_LinkSize; }

        _VT_ TypeSize capacity ()
          { if(TTypeCRTP::ZEUseCRTP<1) return 0;
              return GetChildObj().capacity ();
          }
        _VT_ TypeSize size_free()
          { if(TTypeCRTP::ZEUseCRTP<1) return 0;
              return GetChildObj().size_free();
          }


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

        void pop_front(){DeleteHead();}
        void pop_back (){DeleteTail();}


        TypeData& front(){return GetHeadData();}
        TypeData& back (){return GetTailData();}

        const TypeData& front() const{return GetHeadData();}
        const TypeData& back () const{return GetTailData();}


        template<typename TFunctor> void IterElement(TFunctor AO_Functor)
        {
            ZCLink* VP_LoopLink=mp_HeadLink;

            __for0(TypeSize, i, ml_LinkSize)
            {
                ZtCTypeData<TFunctor>::
                    GetObjRef(AO_Functor)(VP_LoopLink->mo_DataObjt);

                /*  위 코드로 인해서, AO_Functor 이 함수일 때 뿐이 아니라,
                    operator() 연산자를 가진 object 포인터일 때도 사용할 수
                    있게 되었다.

                    이제는 ZftMCP() 템플릿 함수를 사용해도 된다. -- 2025-09-27 00:38
                */
                VP_LoopLink = VP_LoopLink->mp_NextLink ;
            }/*
            __for0(TypeSize, i, ml_Size)*/
        }/*
        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);

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

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

                나

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

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


                이제는 ZtCRef 과 ZCCheckRef 클래스 템플릿을 사용하면 된다. -- 2021-03-11 11:00
                다시 말하면 ZftMCP() 템플릿 함수를 사용하면 된다.          -- 2025-09-27 01:01

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

            typedef ZNsMain::
                ZtCCheckRef<TTypeHelp> ZCCheckRef;

            ZCLink* VP_LoopLink=mp_HeadLink;

            __for0(TypeSize, i, ml_LinkSize)
            {
                ZtCTypeData<TFunctor>::GetObjRef(AO_Functor)
                    (
                        **VP_LoopLink, ZCCheckRef::PassData(AO_TypeHelp)
                    );
                ////////////////////////////////////////////

                /*  위 코드로 인해서, AO_Functor 이 함수일 때 뿐이 아니라, operator()
                    연산자를 가진 object 포인터일 때도 사용할 수 있게 되었다.   */

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

                VP_LoopLink = VP_LoopLink->mp_NextLink ;
            }/*
            __for0(TypeSize, i, ml_Size)*/
        }/*
        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 )
        /*#############################################################################*/
        {
            typedef ZNsMain::ZtCCheckRef<TTypeHelp1> ZCCheckRef1;
            typedef ZNsMain::ZtCCheckRef<TTypeHelp2> ZCCheckRef2;

            ZCLink* VP_LoopLink=mp_HeadLink;

            __for0(TypeSize, i, ml_LinkSize)
            {
                ZtCTypeData<TFunctor>::GetObjRef(AO_Functor)
                    (
                        VP_LoopLink->mo_DataObjt
                      , ZCCheckRef1::PassData(AO_TypeHelp1)
                      , ZCCheckRef2::PassData(AO_TypeHelp2)
                    );
                ////////////////////////////////////////////

                VP_LoopLink = VP_LoopLink->mp_NextLink ;
            }/*
            __for0(TypeSize, i, ml_Size)*/
        }/*
        template
            < typename TFunctor  , typename   TTypeHelp1  , typename   TTypeHelp2   >
        void IterElement
            ( TFunctor AO_Functor, TTypeHelp1 AO_TypeHelp1, TTypeHelp2 AO_TypeHelp2 )
        ###############################################################################*/


        template<typename TFunctor> void IterElemRev(TFunctor AO_Functor)
        {
            ZCLink* VP_LoopLink=mp_TailLink;

            __for0(TypeSize, i, ml_LinkSize)
            {
                ZtCTypeData<TFunctor>::
                    GetObjRef(AO_Functor)(**VP_LoopLink);

                VP_LoopLink = VP_LoopLink->mp_PrevLink ;
            }/*
            __for0(TypeSize, i, ml_Size)*/
        }/*
        template<typename TFunctor> void IterElemRev(TFunctor AO_Functor) */

        template<typename TFunctor, typename TTypeHelp>
            void IterElemRev(TFunctor AO_Functor, TTypeHelp AO_TypeHelp)
        {
            typedef ZNsMain::
                ZtCCheckRef<TTypeHelp> ZCCheckRef;

            ZCLink* VP_LoopLink = mp_TailLink;

            __for0(TypeSize, i, ml_LinkSize)
            {
                ZtCTypeData<TFunctor>::GetObjRef(AO_Functor)
                    (
                        **VP_LoopLink, ZCCheckRef::PassData(AO_TypeHelp)
                    );
                VP_LoopLink = VP_LoopLink->mp_PrevLink ;
            }/*
            __for0(TypeSize, i, ml_Size)*/
        }/*
        template<typename TFunctor, typename TTypeHelp>
            void IterElemRev(TFunctor AO_Functor, TTypeHelp AO_TypeHelp) */


        template
            < typename TFunctor  , typename   TTypeHelp1  , typename   TTypeHelp2   >
        void IterElemRev
            ( TFunctor AO_Functor, TTypeHelp1 AO_TypeHelp1, TTypeHelp2 AO_TypeHelp2 )
        /*#############################################################################*/
        {
            typedef ZNsMain::ZtCCheckRef<TTypeHelp1> ZCCheckRef1;
            typedef ZNsMain::ZtCCheckRef<TTypeHelp2> ZCCheckRef2;

            ZCLink* VP_LoopLink = mp_TailLink;

            __for0(TypeSize, i, ml_LinkSize)
            {
                ZtCTypeData<TFunctor>::GetObjRef(AO_Functor)
                    (
                        VP_LoopLink->mo_DataObjt
                      , ZCCheckRef1::PassData(AO_TypeHelp1)
                      , ZCCheckRef2::PassData(AO_TypeHelp2)
                    );
                VP_LoopLink = VP_LoopLink->mp_PrevLink ;
            }/*
            __for0(TypeSize, i, ml_Size)*/
        }/*
        template
            < typename TFunctor  , typename   TTypeHelp1  , typename   TTypeHelp2   >
        void IterElemRev
            ( TFunctor AO_Functor, TTypeHelp1 AO_TypeHelp1, TTypeHelp2 AO_TypeHelp2 )
        ###############################################################################*/


        template<typename TFunctor> void IterElemLink(TFunctor AO_Functor)
        {
            ZCLink* VP_LoopLink=mp_HeadLink;

            __for0(TypeSize, i, ml_LinkSize)
            {
                ZtCTypeData<TFunctor>::
                    GetObjRef(AO_Functor)( *VP_LoopLink );

                VP_LoopLink = VP_LoopLink->mp_NextLink ;
            }/*
            __for0(TypeSize, i, ml_LinkSize)*/
        }/*
        template<typename TFunctor> void IterElemLink(TFunctor AO_Functor) */


        template<typename TFunctor, typename TTypeHelp>
            void IterElemLink(TFunctor AO_Functor, TTypeHelp AO_TypeHelp)
        {
            typedef ZNsMain::
                ZtCCheckRef<TTypeHelp> ZCCheckRef;

            ZCLink* VP_LoopLink=mp_HeadLink;

            __for0(TypeSize, i, ml_LinkSize)
            {
                ZtCTypeData<TFunctor>::GetObjRef(AO_Functor)
                    (
                        *VP_LoopLink, ZCCheckRef::PassData(AO_TypeHelp)
                    );
                ////////////////////////////////////////////

                VP_LoopLink = VP_LoopLink->mp_NextLink ;
            }/*
            __for0(TypeSize, i, ml_LinkSize)*/
        }/*
        template<typename TFunctor, typename TTypeHelp>
            void IterElemLink(TFunctor AO_Functor, TTypeHelp AO_TypeHelp) */


        template
            < typename TFunctor  , typename   TTypeHelp1  , typename   TTypeHelp2    >
        void IterElemLink
            ( TFunctor AO_Functor, TTypeHelp1 AO_TypeHelp1, TTypeHelp2 AO_TypeHelp2  )
        /*#############################################################################*/
        {
            typedef ZNsMain::ZtCCheckRef<TTypeHelp1> ZCCheckRef1;
            typedef ZNsMain::ZtCCheckRef<TTypeHelp2> ZCCheckRef2;

            ZCLink* VP_LoopLink=mp_HeadLink;

            __for0(TypeSize, i, ml_LinkSize)
            {
                ZtCTypeData<TFunctor>::GetObjRef(AO_Functor)
                    (
                        *VP_LoopLink
                      , ZCCheckRef1::PassData(AO_TypeHelp1)
                      , ZCCheckRef2::PassData(AO_TypeHelp2)
                    );
                ////////////////////////////////////////////

                VP_LoopLink = VP_LoopLink->mp_NextLink ;
            }/*
            __for0(TypeSize, i, ml_LinkSize)*/
        }/*
        template
            < typename TFunctor  , typename   TTypeHelp1  , typename   TTypeHelp2    >
        void IterElemLink
            ( TFunctor AO_Functor, TTypeHelp1 AO_TypeHelp1, TTypeHelp2 AO_TypeHelp2  )
        ###############################################################################*/


        ZCLink* GetHeadLinkPtr(){return mp_HeadLink;}
        ZCLink* GetTailLinkPtr(){return mp_TailLink;}

        const ZCLink* GetHeadLinkPtr() const{return mp_HeadLink;}
        const ZCLink* GetTailLinkPtr() const{return mp_TailLink;}


        IterEasy    GetHeadIterEasy   (){return             GetHeadLinkPtr();}
        IterEasy    GetTailIterEasy   (){return             GetTailLinkPtr();}
        IterEasyID  GetHeadIterEasyID (){return (IterEasyID)GetHeadLinkPtr();}
        IterEasyID  GetTailIterEasyID (){return (IterEasyID)GetTailLinkPtr();}

        IterEasy    GetHeadIterEasy   () const{return             GetHeadLinkPtr();}
        IterEasy    GetTailIterEasy   () const{return             GetTailLinkPtr();}
        IterEasyID  GetHeadIterEasyID () const{return (IterEasyID)GetHeadLinkPtr();}
        IterEasyID  GetTailIterEasyID () const{return (IterEasyID)GetTailLinkPtr();}

        IterEasyIDc GetHeadIterEasyIDc() const{return (IterEasyIDc)GetHeadLinkPtr();}
        IterEasyIDc GetTailIterEasyIDc() const{return (IterEasyIDc)GetTailLinkPtr();}

        void MoveNextIter(ZCLink*&        APR_CLink      ) const
        {
            APR_CLink=APR_CLink->GetNextPtr();
        }
        void MoveNextIter(IterEasyID&     ARRI_IterEasyID) const
        {
            MoveNextIter((ZCLink*&)(ARRI_IterEasyID));
        }
        void MoveNextIter(const ZCLink*&  APR_CLink      ) const
        {
            APR_CLink=APR_CLink->GetNextPtr();
        }
        void MoveNextIter(IterEasyIDc&    ARRI_IterEasyID) const
        {
            MoveNextIter((const ZCLink*&)(ARRI_IterEasyID));
        }/*
        void MoveNextIter(IterEasyIDc&    ARRI_IterEasyID) const*/


        void MovePrevIter(ZCLink*&        APR_CLink      ) const
        {
            APR_CLink=APR_CLink->GetPrevPtr();
        }
        void MovePrevIter(IterEasyID&     ARRI_IterEasyID) const
        {
            MovePrevIter((ZCLink*&)(ARRI_IterEasyID));
        }
        void MovePrevIter(const ZCLink*&  APR_CLink      ) const
        {
            APR_CLink=APR_CLink->GetPrevPtr();
        }
        void MovePrevIter(IterEasyIDc&    ARRI_IterEasyID) const
        {
            MovePrevIter((const ZCLink*&)(ARRI_IterEasyID));
        }/*
        void MovePrevIter(IterEasyIDc&    ARRI_IterEasyID) const*/


        TypeData& GetDataInIter(ZCLink*     AP_CLink       ){return **AP_CLink    ;}
        TypeData& GetDataInIter(IterEasyID  ARRI_IterEasyID)
            { return GetDataInIter((ZCLink*)ARRI_IterEasyID); }

        const TypeData& GetDataInIter(const ZCLink* AP_CLink       ) const
            { return **AP_CLink                                   ; }
        const TypeData& GetDataInIter(IterEasyIDc   ARRI_IterEasyID) const
            { return GetDataInIter((const ZCLink*)ARRI_IterEasyID); }


        TypeData& GetDataInIter( ZCLink* AP_CLink          , TypeSize AI_FarNum)
            {return **(AP_CLink->GetNextPrevPtr(AI_FarNum))            ; }
        TypeData& GetDataInIter( IterEasyID ARRI_IterEasyID, TypeSize AI_FarNum)
            { return GetDataInIter((ZCLink*)ARRI_IterEasyID, AI_FarNum); }

        const TypeData& GetDataInIter( const ZCLink* AP_CLink       , TypeSize AI_FarNum) const
            {return **(AP_CLink->GetNextPrePtr(AI_FarNum))             ; }
        const TypeData& GetDataInIter( IterEasyIDc   ARRI_IterEasyID, TypeSize AI_FarNum) const
            { return GetDataInIter((ZCLink*)ARRI_IterEasyID, AI_FarNum); }



        IterEasy    ItHEasy(){return GetHeadIterEasy  ();}
        IterEasy    ItTEasy(){return GetTailIterEasy  ();}
        IterEasyID  ItHID  (){return GetHeadIterEasyID();}
        IterEasyID  ItTID  (){return GetTailIterEasyID();}

        IterEasyIDc      ItHIDc () const{return GetHeadIterEasyIDc();}
        IterEasyIDc      ItTIDc () const{return GetTailIterEasyIDc();}

        const IterEasy   ItHEasy() const{return GetHeadIterEasy   ();}
        const IterEasy   ItTEasy() const{return GetTailIterEasy   ();}
        const IterEasyID ItHID  () const{return GetHeadIterEasyID ();}
        const IterEasyID ItTID  () const{return GetTailIterEasyID ();}

        void ItNext(ZCLink*&        APR_CLink      ) const{ APR_CLink=APR_CLink->GetNextPtr() ;}
        void ItNext(IterEasyID&     ARRI_IterEasyID) const{ItNext((ZCLink*&)(ARRI_IterEasyID));}
        void ItNext(const ZCLink*&  APR_CLink      ) const{ APR_CLink=APR_CLink->GetNextPtr() ;}
        void ItNext(IterEasyIDc&    ARRI_IterEasyID) const
            { ItNext((const ZCLink*&)(ARRI_IterEasyID)); }

        void ItPrev(ZCLink*&        APR_CLink      ) const{ APR_CLink=APR_CLink->GetPrevPtr() ;}
        void ItPrev(IterEasyID&     ARRI_IterEasyID) const{ItPrev((ZCLink*&)(ARRI_IterEasyID));}
        void ItPrev(const ZCLink*&  APR_CLink      ) const{ APR_CLink=APR_CLink->GetPrevPtr() ;}
        void ItPrev(IterEasyIDc&    ARRI_IterEasyID) const
            { ItPrev((const ZCLink*&)(ARRI_IterEasyID)); }

        TypeData& ItD(IterEasy   AP_CLink       ){return GetDataInIter(AP_CLink       );}
        TypeData& ItD(IterEasyID ARRI_IterEasyID){return GetDataInIter(ARRI_IterEasyID);}

        const TypeData& ItD(const IterEasy  AP_CLink        ) const{return GetDataInIter(AP_CLink       );}
        const TypeData& ItD(IterEasyIDc     ARRI_IterEasyID ) const{return GetDataInIter(ARRI_IterEasyID);}


        TypeData& ItD(IterEasy   AP_CLink       , TypeSize AI_FarNum){return GetDataInIter(AP_CLink       , AI_FarNum);}
        TypeData& ItD(IterEasyID ARRI_IterEasyID, TypeSize AI_FarNum){return GetDataInIter(ARRI_IterEasyID, AI_FarNum);}

        const TypeData& ItD(const IterEasy  AP_CLink        , TypeSize AI_FarNum) const{return GetDataInIter(AP_CLink       , AI_FarNum);}
        const TypeData& ItD(IterEasyIDc     ARRI_IterEasyID , TypeSize AI_FarNum) const{return GetDataInIter(ARRI_IterEasyID, AI_FarNum);}

    public  :
    };/*
    template //////////////////////////////////////////////////////////////////
        <
            typename TType ,
            typename TTypArgu   = const TType&    ,
            typename TTypeAlloc = ZCAllocator     ,
            typename TTypSize   = ZTypLong        ,
            typename TMoveObj   = ZNsMain::
                ZtCMoveObj<TType, TTypArgu, true> ,
            typename TTypeCRTP  = ZNsType::ZtCTypeCRTP<ZCEmpty, false>
        >
    class ZtCBaseList #######################################################*/



    namespace ZNsChars
    {

        template<typename TTypeChars> class ZtCMainChars;

    }/*
    namespace ZNsChars*/



    template< typename TTypeChar, typename TTypeLength=ZTypLength
            >
    class ZtCChars /**#########################################*/
    {
    public :
        template<typename TTypeChars>
            friend class ZNsChars::ZtCMainChars ;
    public :
        typedef       TTypeChar     TypeChar    ;
        typedef       TTypeLength   TypeLength  ;
    public:
        typedef const TTypeChar     TypeCharC   ;
        typedef const TTypeChar*    TypeCharCP  ;
    private:
        TypeChar*     mp_TypeChar  ;
        TypeLength    ml_TypeLength;
    public :

        ZtCChars()
        {
            mp_TypeChar  =0;
            ml_TypeLength=0;
        }/*
        ZtCChars()*/

        ZtCChars(TypeCharC* APC_TypeChar)
        {
            mp_TypeChar   =
                const_cast<TypeChar*>   (APC_TypeChar);
            ml_TypeLength = ZftGetLength(mp_TypeChar );
        }/*
        ZtCChars(TypeCharC* APC_TypeChar)*/

        ZtCChars(TypeCharC* APC_TypeChar, TypeLength AL_Length)
        {
            mp_TypeChar  = const_cast
                <TypeChar*>(APC_TypeChar) ;
            ml_TypeLength= AL_Length      ;
        }/*
        ZtCChars(TypeCharC* APC_TypeChar, TypeLength AL_Length)*/


        void Init()
        {
            mp_TypeChar  = 0;
            ml_TypeLength= 0;
        }/*
        void Init()*/

        void Init(TypeCharC* APC_TypeChar)
        {
            mp_TypeChar  =
                const_cast<TypeChar*>  (APC_TypeChar);
            ml_TypeLength= ZftGetLength(mp_TypeChar );
        }/*
        void Init(TypeCharC* APC_TypeChar)*/

        void Init(TypeCharC* APC_TypeChar, TypeLength AL_Length)
        {
            mp_TypeChar  =const_cast
                <TypeChar*>(APC_TypeChar) ;
            ml_TypeLength=AL_Length       ;
        }/*
        void Init(TypeCharC* APC_TypeChar, TypeLength AL_Length)*/


        void InitData(TypeCharC* APC_TypeChar)
        {
            mp_TypeChar=const_cast<TypeChar*>(APC_TypeChar);
        }/*
        void InitData(TypeCharC* APC_TypeChar)*/

        void InitLength(TypeLength AL_Length)
        {
            ml_TypeLength=AL_Length;
        }/*
        void InitLength(TypeLength AL_Length)*/

        TypeChar*  data()      {return mp_TypeChar  ;}
        TypeCharC* data() const{return mp_TypeChar  ;}
        TypeLength size() const{return ml_TypeLength;}

        ZtCChars& operator+=(TypeLength AI_MovePos)
        {
            return MoveChar(AI_MovePos);
        }/*
        ZtCChars& operator+=(TypeLength AI_MovePos)*/

        int operator-(const ZtCChars& rhs) const
        {
            // 두 문자열이 같으면   0
            // 왼쪽   문자열이 크면 0 보다 큰   어떤 수
            // 오른쪽 문자열이 크면 0 보다 작은 어떤 수를 반환

            TypeCharC* VP_Left =    mp_TypeChar;
            TypeCharC* VP_Right=rhs.mp_TypeChar;

        #if(_CODE_OLD_)
            TypeChar   VC_Minus = 0;
        #else
            int        VI_Minus = 0; // 페이지 하단의 'char 의 int 확장에 따른 문제의 코드' 참고.
        #endif
            TypeLength VL_Index = 0;
            TypeLength VL_Loop  = /*::::::::::::::::::::::::::*/
                (
                    ml_TypeLength <= rhs.ml_TypeLength ?
                    this->ml_TypeLength :
                    rhs.  ml_TypeLength
                ) ;
            /*::::::::::::::::::::::::::::::::::::::::::::::::*/

            while(VL_Index<VL_Loop)
            {
            #if(_CODE_OLD_)
                if((VC_Minus=*VP_Left++ - *VP_Right++)!=0)
                {
                    return VC_Minus;
                }/*
                if((VC_Minus=*VP_Left++ - *VP_Right++)!=0)*/
            #else
                if((VI_Minus=int(*VP_Left++) - int(*VP_Right++))!=0)
                {
                    return VI_Minus; // 페이지 하단의 'char 의 int 확장에 따른 문제의 코드' 참고.
                }/*
                if((VI_Minus=int(*VP_Left++) - int(*VP_Right++))!=0)*/
            #endif

                ++VL_Index;
            }/*
            while(VL_Index<VL_Loop)*/

            return ml_TypeLength-rhs.ml_TypeLength;
        }/*
        int operator-(const ZtCChars& rhs) const*/

        bool operator==(const ZtCChars& rhs) const{return (*this)-rhs == 0 ;}
        bool operator> (const ZtCChars& rhs) const{return (*this)-rhs >  0 ;}
        bool operator< (const ZtCChars& rhs) const{return (*this)-rhs <  0 ;}
        bool operator>=(const ZtCChars& rhs) const{return (*this)-rhs >= 0 ;}
        bool operator<=(const ZtCChars& rhs) const{return (*this)-rhs <= 0 ;}

        ZtCChars& MoveChar(TypeLength AI_MovePos)
        {
            mp_TypeChar   += AI_MovePos ;
            ml_TypeLength -= AI_MovePos ;

            return *this;
        }/*
        ZtCChars& MoveChar(TypeLength AI_MovePos)*/


        ZTypIntI GetInt(bool AB_IsBigEndian=true) const
        {
            ZTycIntI CI_IntByte    = sizeof(ZTypIntI);
            ZTycIntI CI_SearchSize =
                (ml_TypeLength<CI_IntByte ? ml_TypeLength : CI_IntByte) ;

            ZTypIntI VI_Result    = 0 ;
            ZTypIntI VI_TempInt   = 1 ;

            if(AB_IsBigEndian)
            {
                for(ZTypIntI i=CI_SearchSize-1; i>=0; --i)
                {
                    VI_Result  += (ZTypIntI)(ZTypUChar)(mp_TypeChar[i]) * VI_TempInt ;
                    VI_TempInt *= 256 ;
                }/*
                for(ZTypIntI i=CI_SearchSize-1; i>=0; --i)*/

                return VI_Result;
            }/*
            if(AB_IsBigEndian)*/

            for(ZTypIntI i=0; i<CI_SearchSize; ++i)
            {
                VI_Result += (ZTypIntI)(ZTypUChar)(mp_TypeChar[i]) * VI_TempInt ;
                VI_TempInt*= 256 ;
            }/*
            for(ZTypIntI i=0; i<CI_SearchSize; ++i)*/

            return VI_Result;
        }/*
        ZTypIntI GetInt(bool AB_IsBigEndian=true) const*/


        ZTypIntL GetLong(bool AB_IsBigEndian=true) const
        {
            ZTycIntI CI_IntByte    = sizeof(ZTypIntL);
            ZTycIntI CI_SearchSize =
                (ml_TypeLength<CI_IntByte ? ml_TypeLength : CI_IntByte) ;

            ZTypIntL VI_Result    = 0 ;
            ZTypIntL VI_TempInt   = 1 ;

            if(AB_IsBigEndian)
            {
                for(ZTypIntI i=CI_SearchSize-1; i>=0; --i)
                {
                    VI_Result  += (ZTypIntI)(ZTypUChar)(mp_TypeChar[i]) * VI_TempInt ;
                    VI_TempInt *= 256 ;
                }/*
                for(ZTypIntI i=CI_SearchSize-1; i>=0; --i)*/

                return VI_Result;
            }/*
            if(AB_IsBigEndian)*/

            for(ZTypIntI i=0; i<CI_SearchSize; ++i)
            {
                VI_Result  += (ZTypIntI)(ZTypUChar)(mp_TypeChar[i]) * VI_TempInt ;
                VI_TempInt *= 256 ;
            }/*
            for(ZTypIntI i=0; i<CI_SearchSize; ++i)*/

            return VI_Result;
        }/*
        ZTypIntL GetLong(bool AB_IsBigEndian=true) const*/


        ZTypIntLL GetLLong(bool AB_IsBigEndian=true) const
        {
            ZTycIntI CI_IntByte    = sizeof(ZTypIntLL);
            ZTycIntI CI_SearchSize =
                (ml_TypeLength<CI_IntByte ? ml_TypeLength : CI_IntByte) ;

            ZTypIntLL VI_Result   = 0 ;
            ZTypIntLL VI_TempInt  = 1 ;

            if(AB_IsBigEndian)
            {
                for(ZTypIntI i=CI_SearchSize-1; i>=0; --i)
                {
                    VI_Result  += (ZTypIntI)(ZTypUChar)(mp_TypeChar[i]) * VI_TempInt ;
                    VI_TempInt *= 256 ;
                }/*
                for(ZTypIntI i=CI_SearchSize-1; i>=0; --i)*/

                return VI_Result;
            }/*
            if(AB_IsBigEndian)*/

            for(ZTypIntI i=0; i<CI_SearchSize; ++i)
            {
                VI_Result  += (ZTypIntI)(ZTypUChar)(mp_TypeChar[i]) * VI_TempInt ;
                VI_TempInt *= 256 ;
            }/*
            for(ZTypIntI i=0; i<CI_SearchSize; ++i)*/

            return VI_Result;
        }/*
        ZTypIntLL GetLLong(bool AB_IsBigEndian=true) const*/


    public:
    };/*
    template< typename TTypeChar, typename TTypeLength=ZTypLength
            >
    class ZtCChars /**#########################################*/



    namespace ZNsView
    {

        class ZCViewLogData
        {
        public:

            virtual void Log(const char* APC_LogData, ZTypLength AI_Length)
            {
                __for0(ZTypLength, i, AI_Length){cout<<APC_LogData[i];}
            }/*
            virtual void Log(const char* APC_LogData, ZTypLength AI_Length)*/

            virtual void Log(const char* APC_LogData)
                { cout<<APC_LogData; }

            virtual void Log(int    AI_LogData){ cout<<AI_LogData; }
            virtual void Log(long   AL_LogData){ cout<<AL_LogData; }
            virtual void Log(double AD_LogData){ cout<<AD_LogData; }
            virtual void Log(char   AC_LogData){ cout<<AC_LogData; }
            virtual void Log(bool   AB_LogData)
            {
                cout<<(AB_LogData ? "true" : "false");
            }/*
            virtual void Log(bool   AB_LogData)*/

            virtual void LogXmlAtt(const char* APC_LogData, ZTypLength AI_Length)
            {
                __for0(ZTypLength, i, AI_Length)
                {
                    if(APC_LogData[i]=='&' ){cout<<"&amp;" ; continue;}
                    if(APC_LogData[i]=='\r'){cout<<"&#xA;" ; continue;}
                    if(APC_LogData[i]=='\n'){cout<<"&#xD;" ; continue;}
                    if(APC_LogData[i]=='\t'){cout<<"&#x9;" ; continue;}
                    if(APC_LogData[i]=='\"'){cout<<"&quot;"; continue;}
                    if(APC_LogData[i]=='>' ){cout<<"&gt;"  ; continue;}
                    if(APC_LogData[i]=='<' ){cout<<"&lt;"  ; continue;}

                    cout<<APC_LogData[i] ;
                }/*
                __for0(ZTypLength, i, AI_Length)*/
            }/*
            virtual void LogXmlAtt(const char* APC_LogData, ZTypLength AI_Length)*/

            virtual void LogXmlAtt(const char* APC_LogData)
            {
                LogXmlAtt(APC_LogData, ZftLength(APC_LogData));
            }/*
            virtual void LogXmlAtt(const char* APC_LogData)*/

        public:
        };/*
        class ZCViewLogData*/

    }/*
    namespace ZNsView*/



    class ZCSngtLogData
    {
    public :
        typedef ZNsView::ZCViewLogData ZCViewLogData;
    private:
        ZCViewLogData  mo_ZCViewLogData;
        ZCViewLogData* mp_ZCViewLogData;
    private:
        ZCSngtLogData() : mp_ZCViewLogData(&mo_ZCViewLogData){}
    public :

        static ZCSngtLogData& GetSngtObj()
        {
            static ZCSngtLogData SO_ZCSngtLogData; return SO_ZCSngtLogData;
        }/*
        static ZCSngtLogData& GetSngtObj()*/

        static ZCViewLogData& GetSngtView()
        {
            return *GetSngtObj().mp_ZCViewLogData;
        }/*
        static ZCViewLogData& GetSngtView()*/

        static void SetSngtView(ZCViewLogData& AR_ViewObj)
        {
            GetSngtObj().mp_ZCViewLogData = &AR_ViewObj ;
        }/*
        static void SetSngtView(ZCViewLogData& AR_ViewObj)*/

    public :

        static void Log(const char* APC_Log, ZTypLength AI_Length)
        {
            GetSngtView().Log(APC_Log, AI_Length);
        }/*
        static void Log(const char* APC_Log, ZTypLength AI_Length)*/

        static void Log(const char* APC_LogData)
        {
            GetSngtView().Log( APC_LogData );
        }/*
        static void Log(const char* APC_LogData)*/

        static void Log(int    AI_LogData){ GetSngtView().Log(AI_LogData); }
        static void Log(long   AL_LogData){ GetSngtView().Log(AL_LogData); }
        static void Log(double AD_LogData){ GetSngtView().Log(AD_LogData); }
        static void Log(char   AC_LogData){ GetSngtView().Log(AC_LogData); }
        static void Log(bool   AB_LogData){ GetSngtView().Log(AB_LogData); }

        static void LogXmlAtt(const char* APC_LogData, ZTypLength AI_Length)
        {
            GetSngtView().LogXmlAtt(APC_LogData, AI_Length);
        }/*
        static void LogXmlAtt(const char* APC_LogData, ZTypLength AI_Length)*/

        static void LogXmlAtt(const char* APC_LogData)
        {
            GetSngtView().LogXmlAtt(APC_LogData);
        }/*
        static void LogXmlAtt(const char* APC_LogData)*/

    public :

        ZCSngtLogData& operator()(const char* APC_Log, ZTypLength AI_Length)
        {
            ZCSngtLogData::Log(APC_Log, AI_Length); return *this;
        }/*
        ZCSngtLogData& operator()(const char* APC_Log, ZTypLength AI_Length)*/

        ZCSngtLogData& operator()(const char* APC_LogData)
        {
            GetSngtView().Log( APC_LogData ); return *this;
        }/*
        ZCSngtLogData& operator()(const char* APC_LogData)*/

        ZCSngtLogData& operator()(int    AI_LogData){ GetSngtView().Log(AI_LogData); return *this; }
        ZCSngtLogData& operator()(long   AL_LogData){ GetSngtView().Log(AL_LogData); return *this; }
        ZCSngtLogData& operator()(double AD_LogData){ GetSngtView().Log(AD_LogData); return *this; }
        ZCSngtLogData& operator()(char   AC_LogData){ GetSngtView().Log(AC_LogData); return *this; }
        ZCSngtLogData& operator()(bool   AB_LogData){ GetSngtView().Log(AB_LogData); return *this; }

        ZCSngtLogData& Xa(const char* APC_LogData, ZTypLength AI_Length)
        {
            GetSngtView().LogXmlAtt(APC_LogData, AI_Length); return *this;
        }/*
        ZCSngtLogData& Xa(const char* APC_LogData, ZTypLength AI_Length)*/

        ZCSngtLogData& Xa(const char* APC_LogData)
        {
            GetSngtView().LogXmlAtt(APC_LogData); return *this;
        }/*
        ZCSngtLogData& Xa(const char* APC_LogData)*/

    public :
    };/*
    class ZCSngtLogData*/

}/*
namespace ZNsMain*/




namespace ZNsCPP
{

    using ZNsMain::IterEasyID;

    /*  이 이름공간에는 ZNsMain 에 있는 라이브러리 보다 좀더 thread-safe
        하거나 좀더 최적화된, 아니면 좀 더 gerneric 한 자료구조가 온다.
    */
    namespace ZNsIFace
    {
    }/*
    namespace ZNsIFace*/

    namespace ZNsType
    {
    }/*
    namespace ZNsType*/

    namespace ZNsEnum
    {
    }/*
    namespace ZNsEnum*/

    namespace ZNsConst
    {
    }/*
    namespace ZNsConst*/

}/*
namespace ZNsCPP */


/* 함수 안에서 함수를 정의할 필요가 있을 때, struct 를 이용하여 함수를 정의하는 매크로. -- 2015-09-06 05:20:00 */

#define _FUNC_IN_FUNC_START_(ZstClassName) struct ZstClassName{static void Exec
#define _FUNC_IN_FUNC_CLOSE_(ZstClassName) };

#define _FUNC_IN_FUNC_RETURN_START_(ZstClassName, ZTypeReturn) struct ZstClassName{static ZTypeReturn Exec
#define _FUNC_IN_FUNC_RETURN_CLOSE_(ZstClassName, ZTypeReturn) };

#define _FFS_(ZstClassName) _FUNC_IN_FUNC_START_(ZstClassName)
#define _FFC_(ZstClassName) _FUNC_IN_FUNC_CLOSE_(ZstClassName)
#define _FFE_(ZstClassName) }; // E 문자는 END 의 뜻.

#define _FFRS_(ZstClassName, ZTypeReturn) _FUNC_IN_FUNC_RETURN_START_(ZstClassName, ZTypeReturn)
#define _FFRC_(ZstClassName, ZTypeReturn) _FUNC_IN_FUNC_RETURN_CLOSE_(ZstClassName, ZTypeReturn)
#define _FFRE_(ZstClassName) };

#define _FFF_(ZstClassName) ZstClassName::Exec

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

■  _FUNC_IN_FUNC_START_ 관련 매크로 사용예.

    #include<iostream>

    using namespace ZNsMain;

    int main()
    {
        _FUNC_IN_FUNC_START_(My)
            (IntI ArgiShowCnt)
            {
                for(int i=0; i<ArgiShowCnt; ++i) cout<<"# Show My() In Func."<<endl;
            }
        _FUNC_IN_FUNC_CLOSE_(My)

        _FUNC_IN_FUNC_RETURN_START_(My2, Int)
            (IntI ArgiShowCnt)
            {
                for(int i=0; i<ArgiShowCnt; ++i) cout<<"# Show My() In Func."<<endl; return ArgiShowCnt;
            }
        _FUNC_IN_FUNC_RETURN_CLOSE_(My2, int)

        _FFS_(My3)
            (IntI ArgiShowCnt)
            {
                for(int i=0; i<ArgiShowCnt; ++i) cout<<"# Show My() In Func."<<endl; return ArgiShowCnt;
            }
        _FFC_(My3)

        My ::Exec(3);
        My2::Exec(3);
        My3::Exec(3);


        return 0;
    }

    --  2015-09-06 17:21:00

    CNetEx.H 의 HandleEvent 도 참고. -- 2015-09-06 17:43:00

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




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

■  4.1 자동적으로 정의되는 심볼들

    여러분은 여러분이 갖고 있는 버전의 gcc 가 -v 옵션을 붙임으로써
    어떠한 심볼을 자동적으로 정의하는지 알아낼 수 있다.
    예를 들어 본인의 것은 다음과 같다.

    $ echo 'main(){printf("hello world\n");}' | gcc -E -v -
    Reading specs from /usr/lib/gcc-lib/i486-box-linux/2.7.2/specs
    gcc version 2.7.2
     /usr/lib/gcc-lib/i486-box-linux/2.7.2/cpp -lang-c -v -undef
    -D__GNUC__=2 -D__GNUC_MINOR__=7 -D__ELF__ -Dunix -Di386 -Dlinux
    -D__ELF__ -D__unix__ -D__i386__ -D__linux__ -D__unix -D__i386
    -D__linux -Asystem(unix) -Asystem(posix) -Acpu(i386)
    -Amachine(i386) -D__i486__ -

    --

    현재 위 명령으로는 더 이상 매크로를 알 수 없는데, 아래 명령

        echo . | gcc -dM -E -

    혹은

        gcc -dM -E - < /dev/null

    을 이용하면 된다.

    ex) gcc -dM -E - < /dev/null | grep 'linux'

        #define __linux 1
        #define __linux__ 1
        #define __gnu_linux__ 1
        #define linux 1

    ex) echo . | gcc -dM -E - | grep 'unix'

        #define __unix 1
        #define __unix__ 1
        #define unix 1

    이것은 ymir 님의 답변이었다. ☞ http://kldp.org/node/121720

    -- 2011-03-03 13:21:00

■  각 OS 별 매크로

    리눅스 : #define __linux__ 1
    HP     : #define __hpux__  1
    sun    : #define __sun__   1
    IRIX   : #define __mips__  1
    TRUE64 : #define __alpha__ 1
    FreeBSD: #define __FreeBSD_cc_version 800001
             #define __VERSION__ "4.2.1 20070719  [FreeBSD]"
             #define __FreeBSD__ 8
    AIX    : #define _AIX 1
             #define _AIX32 1
             #define _AIX41 1
             #define _AIX43 1
             #define _AIX51 1
             #define _AIX52 1
             #define _AIX53 1

    -- 2011-03-12 16:17:00

■  만약 여러분의 코드가 리눅스에만 관계되는 코드라면, 다음과 같이 해주는 것이 좋다.

    #ifdef __linux__

    // ... funky stuff ...

    #endif // __linux__

    __linux__라는 이름을 사용하라. linux 가 아니다.
    후자가 정의되어 있기는 하지만 POSIX 규격에는 맞지 않기 때문이다.

■  각 OS 별 Shared Library PATH 환경 변수 (2012-04-08 19:25:00)

    ※  http://cafe335.daum.net/_c21_/bbs_search_read?grpid=TzUN&fldid=DUnV&contentval=0000szzzzzzzzzzzzzzzzzzzzzzzzz&nenc=&fenc=&q=gulim.ttf&nil_profile=cafetop&nil_menu=sch_updw

    AIX            LIBPATH, LD_LIBRARY_PATH
    OS/2           LIBPATH
    Windows NT/95  PATH
    Solaris/Linux  LD_LIBRARY_PATH
    HP/UX          SHLIB_PATH, LD_LIBRARY_PATH (64 bit only)

    ex) export LD_LIBRARY_PATH=$LD_LIBRARY_PATH:/userJNI/lib

    ※  HP-UX 에서 Shared Library 의 확장자는 sl 이다.

    □  SUN일 경우 LD_LIBRARY_PATH 를 HP-UX 일 경우 SHLIB_PATH 를, AIX 일 경우 LIBPATH 를 사용합니다. 

    □  참고 : HP에서 LD_LIBRARY_PATH 는 64비트 환경에서만 작동함. 확장자 명도 sl 임 

    □  chatr 명령을 사용하면 SHLIB_PATH가 사용 중인 프로그램에 대해 "사용 불가능" 상태인지 여부를 판별할 수 있습니다.

        다음 예는 /opt/mqm/samp/bin/amqsput 프로그램에 사용되는 chatr 명령입니다.

            chatr /opt/mqm/samp/bin/amqsput

        프로그램이 SHLIB_PATH를 사용하는지 확인하려면 다음 명령을 실행하십시오. 

            chatr +s enable /opt/mqm/samp/bin/amqsput

        SHLIB_PATH 가 환경에 정의되어 있으며 /usr/lib 디렉토리를 포함하는지 확인하십시오(echo $SHLIB_PATH).

        경로를 정의하려면 다음을 실행하십시오.

            export SHLIB_PATH=$SHLIB_PATH:/usr/lib

    □  다음은 어플리케이션에 대해 SHLIB_PATH 또는 chatr +s 가 조사되어야 함을 지시하는 어플리케이션 오류입니다. 

        ◆  IBM WebSphere MQ 프로그램 runmqsc

            runmqsc D11LHP.QM
            5724-B41 (C) Copyright IBM Corp. 1994, 2002.  ALL RIGHTS RESERVED.
            Starting MQSC for queue manager D11LHP.QM.
            /usr/lib/dld.sl: Can't find path for shared library: libstream.2
            /usr/lib/dld.sl: No such file or directory
            AMQ9508: Program cannot connect to the queue manager.
            No MQSC commands read.
            No commands have a syntax error.
            All valid MQSC commands were processed.

        ◆  IBM WebSphere MQ 샘플 어플리케이션이 권한 부여 오류를 표시함(이유 코드 2217)

            amqsput QL_D11LHP_B02KLNX.U1.I D11LHP.QM
            Sample AMQSPUT0 start
            target queue is QL_D11LHP_B02KLNX.U1.I
            MQOPEN ended with reason code 2217
            unable to open queue for output
            Sample AMQSPUT0 end

        ◆  --

    □  --

■  'new operator' 와 'operator new' Programming

    (2007/04/03 16:20)
    http://blog.naver.com/cppis/60036113050
 
    bugmail 에게 More Effective C++을 빌려 보던 중 일반적으로 많이 쓰던 new 와 delete 에 대해
    서 소홀하게 넘어갔던 부분을 보고 정리를 하게 되었습니다. 저와 마찬가지로 많은 사람들이

        new operator 와 operator new

    를 혼동하시는 것 같아서 간단히 정리해봤습니다.

    new operator 는 C++ 에서 제공하는 연산으로 두 가지 동작을 수행합니다.

      --  먼저, 요청한 타입 크기의 메모리를 할당하고, 다음으로,
      --  타입 인스턴스의 생성자를 호출하여 초기화를 수행합니다.

    C++ 컴파일러는 new operator 를 위의 내용처럼 코드로 만들어냅니다. operator new 란 바로 요
    청한 타입 크기의 메모리를 할당하는 동작을 수행하는 Operator 입니다.

    따라서 위의 내용을 다시 요약하면, new operator 는

        operator new 로 메모리를 할당하고, object 의 생성자를 호출하는 동작을 한다.

    라고 할 수 있습니다.

    operator new 는 Overload 될 수 있기 때문에 사용자가 자신만의 'operator new'를 정의할 수
    있습니다. 또, 항상 void* 를 리턴하고, 첫번째 인자로 size_t 를 받습니다. new operator 의
    문법은 다음과 같습니다.

        [::] new [placement] new-type-name [new-initializer]
        [::] new [placement] ( type-name ) [new-initializer]

    - placement

    new 를 overload 할 때 추가로 인자를 전달하는 방법을 제공합니다. 예를 들어, 표준 C++ 라이
    브러리의 default new는 메모리가 바닥나면 exception 을 throw 합니다. Overload 된 new 는 대
    신 NULL 을 리턴하는데, Overload 된 new 는 다음과 같이 정의되어 있습니다.

        struct nothrow_t {};
        extern const nothrow_t nothrow;
        void *operator new throw() (size_t, const nothrow_t& );

    그리고 다음과 같이 호출될 수 있습니다

        foo *fp = new (nothrow) foo;
        if( !fp ) {
         // Out of memory를 처리합니다.
        }

    - type-name
    할당할 타입을 명시합니다. type-name 은 built-in 이거나 user-defined 타입일 수 있습니다.

    - initializer
    초기화할 object 를 위한 값을 제공합니다. initializer 는 object  배열을 할당하기 위해서는
    사용될 수 없습니다. new operator 는 default 생성자를 가지고 있는 object 의 배열만을 생성
    할 수 있습니다.

    new 중에서 Placement-new 는 메모리를 전혀 할당하지 않고, object 의 생성자를 호출하기 위해
    서만 사용됩니다. Placement-new 는 일반적으로 다음과 같이 정의되어 있습니다.

        inline void *operator new( size_t, void* p )
        {
            return p;
        }

    Automatic Variable 을 제외한다면 Placement-new 는 object 의 생성자를 호출할 수 있는 유일
    한 방법입니다. new 와 쌍(Pair)인 delete도 이와 비슷합니다.

        'delete operator'는 object 의 소멸자를 호출하고,
        'operator delete'를 호출하여 메모리를 해제하는 동작을 수행합니다.

    reference

    - More Effective C++
    - MSDN

■  Placement-New Requires Heap-Allocated Buffers

    The placement-new operator constructs an object on a pre-allocated buffer. The pre-allocated buffer has to be allocated
    on the heap.
 
        char *pbuff = new char[1024]; // heap allocation using plain new
        Person *p = new (pbuff) Person; // placement new uses a pre-allocated buffer

    You may be tempted to use a buffer allocated on the stack to avoid the need of explicitly freeing it:
 
        char pbuff [1024];  //bad idea: stack allocation instead of heap
        Person *p = new ( pbuff ) Person;  //undefined behavior

    However, the pre-allocated buffer must comply with certain alignment constraints required by C++. Memory allocated
    on the heap is guaranteed to comply with these requirements. Stack memory, on the other hand, may not be properly aligned,
    and hence using it for that purpose yields undefined behavior

    -- heap 에서는 정렬 제한이 정확히 지켜지지만
    -- stack 에서는 정렬 제한이 지켜지지 않을 수 있다.
    -- (아마도 위에서 버퍼 pbuff[1024] 의 주소 pbuff 이 heap 기준에 어긋나는,
    -- 정렬되지 않은 주소일 수도 있다는 뜻인 듯 하다.) 2008-10-26

    http://kldp.org/node/76375
    http://www.devx.com/tips/Tip/12756

■  어떤 클래스에 멤버변수를 추가하게 되면 생성자에서 초기화해야 하는지 한 번 더 생각하자. 생
    성자에서 초기화를 빠트려서 애먹은 적이 있었다.

■  클래스가 어떤 주기적인 상태를 가지는 경우, 한 주기가 끝날 때마다 내부 버퍼를 정확하게 초
    기화하자. 각 포탈이나 신문사의 검색페이지에서 검색결과를 가져와 해석할 때, 각 검색 페이지
    의 각 리스트 항목의 데이타 추출이 끝나면, 다음 리스트 항목을 추출할 때 관련 버퍼를 초기화
    해 주어야 했는데 여기에 실수가 있어서, 추출시에 이전 정보가 자꾸 들러 붙었다. 처음에는 이
    게 오류인 줄 알았고 들러붙은 것이 이전 정보인지도 몰랐다. 알고보니 다음 항목 추출 전에 관
    련 버퍼를 초기화 안한 실수였다.

■  가상함수를 상속클래스에서 재정의할 때는 기본값 인수 갯수도 동일해야 한다.

        virtual CIOCP  ::SendPacket(HANDLE SocketID,const char* ApcData=0,int AI_Length=0,CSendBuffList* AP_CSendBuffList=0) // 1) 번코드
        virtual CIOCPEx::SendPacket(HANDLE SocketID,const char* ApcData=0,int AI_Length=0)                                   // 2) 번코드

    1) 번 코드는 기반클래스의 가상  함수이고
    2) 번 코드는 상속클래스의 재정의함수다. 그리고 아래의 코드에서

        CIOCPEx VO_CIOCPEx;
        CIOCP*  VP_CIOCP=&VO_CIOCPEx;

        VO_CIOCPEx->SendPacket((HANDLE)100,"my",2); // 어느 함수가 호출될까.

    위 코드는 CIOCP::SendPacket() 을 호출하게 된다.

    -- 2009-01-03 13:09:00

■  여러 오브젝트 파일에서 사용되는 문자열 상수는

    const char*       CPC_MySQL_Host="localhost" 이 아니고
    const char* const CPC_MySQL_Host="localhost" 로 선언해야 한다.

■  템플릿으로 상속을 구현하면, 템플릿 parameter 에 따라 기반 클래스를 마음대로 바꿀 수가 있다. 이 기능이 상당히 편하
    긴 한데 조심할 점이 한 가지 있다.

        template<typename TTypeBase>
        class CMy : public TTypeBase
        {
        public:
            void Init();
            void Fini();
        };

    위 클래스 템플릿을 상속해서 CMy2 를 만든다음
    clear() 멤버를 추가한다고 하자. 그러면

        class CMy2 : public CMy<CBaseClass>
        {
        public:
            void clear();
        };

    위외 같은 형태가 될텐데, 이때 clear() 멤버를 정의하면서 기반 클래스인 CMy<CBaseClass> 의 멤버변수와 함수를 어떻게
    사용하겠는지 한 번쯤 생각을 하게 된다. 그런데 CMy<CBaseClass> 의 기반클래스인 CBaseClass 에 대해서는 자칫 생각을
    못하게 된다. clear() 함수가 어떤 자원을 해제하는 함수라면 CBaseClass 의 관련 자원을 해제하는 처리를 빠트릴 수 있는
    것이다. 따라서 템플릿 기반의 상속 구현에서 기반클래스의 관련 멤버에 대해서도 어떤 처리가 필요한지 한 번 더 따져봐
    야 한다.

    상속클래스를 템플릿 parameter 로 받는 클래스 템플릿을 상속하는 경우에도 마찬가지로 주의해야 한다.

    CHttp.H 파일에서 std::ZNsCGI::ZNsThpe::ZtCTypeLoadDataQuery_T<> template 에서도 clear() 멤버를 Override 하고 있는데,
    위와 상황은 약간 다르지만 유사한 헛점이 생겼던 코드이다. clear() 멤버는 자원을  해제하는 함수인데 이 함수를 재정의
    하지 않는 상태에서

        ZtCTypeLoadDataQuery_T<>  ::clear()   을 호출하니
        std::CLoadDataBlockOne_T<>::clear() 만을 호출하고

    또다른 기반 클래스인 TTypeBase 의 자원을 해제하지 못하고 있었다. 그래서 부랴부랴 TTypeBase 인자에 해당하는 클래스
    에 clear() 멤버를 추가하고 ZtCTypeLoadDataQuery_T<>::clear() 을 재정의한 함수 정의에, 코드

        std::CLoadDataBlockOne_T<>::clear()
        this->TTypeBase           ::clear()

    을 추가시켰다. 그제야 결과가 정상이었다. 이전에는 이상하게 짝수번 실행시에 결과가 엉뚱하게 나왔었다. clear() 시에
    기반클래스 TTypeBase 인

        std::ZNsIFace::CDeriveLoadDataQuery_T<TString>

    클래스에서 멤버 me_ESearch 을 ESearch_Name 으로 초기하지 못하고 있었던 것이다. 그러니까 처음 실행시에는
    
        me_ESearch==ESearch_Name 이니까 정상이고 2 번째 실행시에
        me_ESearch!=ESearch_Name 이니까 엉뚱한 결과가 나오고, 이때 우연치 않게도
        me_ESearch==ESearch_Name 으로 다시 초기화되고, 3 번째 실행시에는
        me_ESearch==ESearch_Name 이니까 정상이고...

    게다가 갑자기 breakpoint 가 먹질 않고... 휴 진땀뺏다. -- 2009-01-05 10:02:00

■  CHttp.H 에 가상 기초 클래스가 필요한 상황에 어떻게 템플릿으로 구현하는지 그 예가 있다. 여러 개의 상속클래스에서
    공통이 되는 멤버를, 상속 클래스에서 선언및 정의하는 방법을 사용하고 있다.

    이 방법을 "가상 상속의 템플릿 구현(TIVI : Template Implementation Of Virtual Inheritance)" 이라고 하자.

    CHttp.H 에서 사용한 이런 기법이 다른 경우에도 적용될 수 있다. 프로그램이 커지면 여러 가지 클래스를 정의하게 되고,
    어떠 클래스를 정의하기 전에, 다른 클래스 정의를 요구하고 또 다른 클래스 object 를 요구할 수 있다. 다른 클래스 정의
    를 요구하는 경우는 그 클래스 앞에 요구하는 클래스를 미리 정의하면 간단한데, 다른 클래스 object (참조, 포인터) 를
    외부에서 요구하는 경우는 처리가 복잡해진다. 그때마다 전역 인스턴스를 만들자니 뭔가 찝찝하다. 예를 들어 A/B/C/D/E
    클래스가 있는데

    B 는 외부의 A 의 object 참조를 요구하고
    C 는 외부의 B 의 object 참조를 요구하고
    D 는 외부의 C 의 object 참조를 요구하고
    E 는 외부의 D 의 object 참조를 요구하는 상황이라고 하자. 그러면

    A 를 정의하고 A 전역 object 를 만들고
    B 를 정의하고 B 전역 object 를 만들고
    C 를 정의하고 C 전역 object 를 만들고
    D 를 정의하고 D 전역 object 를 만드는 과정을 반복해야 한다.

    이렇게 하면 전역object 가 어지럽게 널려 있게 된다. 이런 상황에서도 "가상 상속의 템플릿 구현" 을 사용할 수 있겠다.

    -- 2009-01-18 17:48:00

    음, "가상 상속의 템플릿 구현" 을 좀 더 곰곰히 생각해 보면, 스트립트 언어에서는 이런 경우를 '어떻게 처리할까' 라는
    궁금증이 생긴다. 근데 스트립트 언어에서는 데이타형에서 자유롭기 때문에 이런 상황을 풀어 내기가 훨씬 쉬워 보인다.
    데이타형에서 자유롭기 때문에 얻어지는 이 장점이 과연 좋은 것일까. 버그가 더 발생하기 쉽지 않을까.

    -- 2009-01-19 01:21:00

    위에서 예로 든 object  A,B,C,D,E 의 관계를 이렇게 풀 수도 있겠다.

    A 를 정의하고
    A 의 참조(나 포인터)를 생성자에서 인수로 받는 클래스 B 를 만들고
    B 의 참조(나 포인터)를 생성자에서 인수로 받는 클래스 C 를 만들고
    C 의 참조(나 포인터)를 생성자에서 인수로 받는 클래스 D 를 만든다.

    이 개념을 가상 함수로 풀면,

    A 를 정의하고
    A 의 기초 클래스의 참조(나 포인터)를 생성자에서 인수로 받는 클래스 B 를 만들고
    B 의 기초 클래스의 참조(나 포인터)를 생성자에서 인수로 받는 클래스 C 를 만들고
    C 의 기초 클래스의 참조(나 포인터)를 생성자에서 인수로 받는 클래스 D 를 만든다.

    -- 2009-01-19 01:26:00

    이런 상황이 더 복잡해진다면 적절한 작업쓰레드를 모델링해서 해결하는 것도 좋을 것 같다.

    (WTM 은 Working Thread Model)

    A 의 역할을 하는 IOCP 형 작업쓰레드 모델 A-WTM 을 만들고
    B 의 역할을 하는 IOCP 형 작업쓰레드 모델 B-WTM 을 만들고
    C 의 역할을 하는 IOCP 형 작업쓰레드 모델 C-WTM 을 만들고 ...

    만약 A,B 나 C,D 를 하나의 단위로 묶을 수 있다면,

    A,B 의 역할을 하는 IOCP 형 작업쓰레드 모델 AB-WTM 을 만들고
    C,D 의 역할을 하는 IOCP 형 작업쓰레드 모델 CD-WTM 을 만들고...

    --

    이 문제는 COM(Component Object Model) 방식으로 해결할 수도 있겠다.

    cf) std::ZNsIFace::ZIDelgtMSG

    -- 2009-03-09 20:18:00

    "가상 상속의 템플릿 구현"은 꼭 가상 함수의 다중 상속이 필요한 상황 외에도 클래스 A, B, C, D 가 서로의 인터페이스에
    접근하는 복잡한 상황에서도 사용할 수 있겠다. 클래스 A, B, C, D 를 상속클래스 템플릿인자를 받도록 선언하고, 클래스
    A, B, C, D 를 상속하는 클래스 E 를 만든 다음에, 이 E 를 통해 A, B, C, D 각 클래스에 접근할 수 있다. 즉 상속클래스
    가 기반 클래스들의 중간 다리역할을 하고 있는 것이다.

    cf) MainHead_VirtualDeriveTmpl.cpp


    "가상 상속의 템플릿 구현" 은 CURIOUSLY RECURRING TEMPLATE PATTERN 과 일맥상통한다.

    class template A 가 다수 개의 class B1, B2, B3 의 존재를 알아야 하고, 또 class B1, B2, B3 는 A 의 존재를 알아야 하
    는 순환 인식 구조에서도 적용하면 아주 좋을 것 같다. 또한 class B1, B2, B3 가 서로의 존재를 알아야 할 때도 유용하다.
    class B1, B2, B3 의 멤버함수를 호출할 때, A 의 상속클래스 A2 를 넘기면, A2 에 B1, B2, B3 에 접근하는 interface 가
    있기 때문에, B1 에서 B2 나 B3 의 interface 에 접근할 수가 있는 것이다.

    ex)

    1)  먼저 상속 클래스를 템플릿 인자로 받는 class template A 를 정의한다.
    2)  A 의 상속 클래스에 B1, B2, B3 클래스의 인터페이스가 있다는 가정하에
        B1, B2, B3 클래스의 인터페이스를 사용하는 멤버함수를 A 에 추가한다.
    3)  A 의 상속 클래스에서, B1, B2, B3 클래스 object 에 접근할 수 있는,
        인터페이스를 정의한다.

    template<typename TParent>
    class A
    {
    public:
        void UseB1(){static_cast<TParent*>(this)->GetObjB1().CallFunc();}
        void UseB2(){static_cast<TParent*>(this)->GetObjB2().CallFunc();}
        void UseB3(){static_cast<TParent*>(this)->GetObjB3().CallFunc();}
        void UseExB1(TParent& ArCParent){static_cast<TParent*>(this)->GetObjB1().CallFunc(ArCParent);}
        void UseExB2(TParent& ArCParent){static_cast<TParent*>(this)->GetObjB2().CallFunc(ArCParent);}
        void UseExB3(TParent& ArCParent){static_cast<TParent*>(this)->GetObjB3().CallFunc(ArCParent);}
    };

    class A2 : public A<A2>
    {
    public:
        class B1{public:void CallFunc()        {cout<<"Call B1::CallFunc()"<<endl;}
                        void CallFunc(A2& ArA2){cout<<"Call B1::CallFunc(A2)"<<endl;}};
        class B2{public:void CallFunc()        {cout<<"Call B2::CallFunc()"<<endl;}
                        void CallFunc(A2& ArA2){cout<<"Call B2::CallFunc(A2)"<<endl;}};
        class B3{public:void CallFunc()        {cout<<"Call B3::CallFunc()"<<endl;}
                        void CallFunc(A2& ArA2){cout<<"Call B3::CallFunc(A2)"<<endl;}};
    private:
        B1 b1;
        B2 b2;
        B3 b3;
    public:
        B1 GetObjB1(){return b1;}
        B2 GetObjB2(){return b2;}
        B3 GetObjB3(){return b3;}
        void UseExB1(){A<A2>::UseExB1(*this);}
        void UseExB2(){A<A2>::UseExB2(*this);}
        void UseExB3(){A<A2>::UseExB3(*this);}
    };


    A2 myA2;

    myA2.UseB1();
    myA2.UseB2();
    myA2.UseB3();
    myA2.UseExB1();
    myA2.UseExB2();
    myA2.UseExB3();

    -- 2010-03-12 11:56:00

    그런데 가상 함수 클래스를 이용하면 더 간단할 수 있다. 예를 들어 클래스 A,B,C 에 접근할 수 있는 인터페이스를 제공하
    는 가상 함수 클래스 IA, IB, IC 를 만들고, 클래스 A, B, C 는 각각 IA, IB, IC 클래스를 상속한다. 그 다음 IA, IB, IC
    의 포인터를 관리하는 singleton object SngtA, SngtB, SngtC 를 정의하고, 클래스 A, B, C 는 생성후, 바로(혹은 빠른 시
    간 안에), SngtA, SngtB, SngtC 가 관리하는 가상함수 클래스의 포인터를 자신의 포인터로 설정해 준다.

    이러면 A, B, C 는 singleton object SngtA, SngtB, SngtC 를 통해 서로의 interface 를 호출할 수 있다. 가상 함수의 사
    용이 부담되지 않는다면 이 방법이 더 편할 수 있다.

    -- 2010-03-13 22:43:00

■  작업 쓰레드 pool P1 에서 class A, B 를 사용하는데, A,B 는 P1 보다 먼저 선언해야 하지만, B 는 내부적으로 P1 을 사용
    하고 있어서 P1 이후에 선언해야 한다고 생각해보자. 그러면 선언/정의 순서가 A => P1 => B 가 된다. 그런데 P1 은 B 라
    는 자료형을 알아야 하는데, 이것은 P1 의 작업쓰레드의 수행 함수를 템플릿으로 만들어서 인자를 받게 하고, P1 의 Instance
    를 B 에서 만들면서 템플릿 인자로 B 를 넘겨주면 된다.

    클래스 테플릿 CThreadEx_T<> 와 파일 CProxySockHttpXml.H 을 참고한다.

    -- 2009-08-09 20:23:00

■  기초클래스의 생성자에서 파생클래스의 참조(나 포인터)를 인수로 받는 경우가 있는데, 이때 기초 클래스의 생성자에서는
    파생클래스의 멤버가 초기화되기 전이므로, 파생 클래스의 멤버 변수에 접근하거나 파생 클래수의 멤버 변수를 사용하는
    함수를 호출해서는 안된다. 단, 파생클래스의 각 멤버를 초기화하는, 파생클래스의 어떤 멤버 함수를 호출한 후라면 상관
    없다.

    -- 2009-02-10 23:02:00

■  VC++ 2008 에서 "도구 => 옵션 => '프로젝트 밑 솔루션' => VC++ 디렉토리" 에서 해당 라이브러리의 헤더 파일과 라이브러
    리 파일을 "포함파일" 과 "라이브러리 파일" 에 설정을 했어도 해당 경로에서 라이브러리를 못찾는 경우가 있다. 이때는
    "프로젝트 => 속성" 에서 헤더 파일과 라이브러리 파일의 경로를 또 적어주어야 한다.

    -- 2009-02-27 10:02:00

■  멤버 함수 템플릿은 가상 함수가 될 수 없다. -- 2009-02-28 04:21:00

■  C# 의 delegate 삼아서 std:ZNsIFace::ZIDelgtMSG 클래스를 설계하였다. 이 object 로부터 메시지를 수신하는 클래스는 이
    클래스를 상속하거나, 이 클래스를 상속하여 관련 interface 를 재정의한 클래스를 멤버 변수로 가지고 있는 것이 좋다.
    특히 다수의 메시지를 수신받아야 하는 경우에는 다수의 멤버 변수로 설계하는 것이 좋다.

    결국 ZIDelgtMSG 에서 정한 interface 만 사용할 수 있는 것인데, 이런 때는 COM(Component Object Model) 이 참 편리하게
    느껴진다. 또한 C++ 표준에도 COM 이 들어가면 좋겠다는 생각을 하게 된다.

    -- 2009-03-01 12:04:00

■  다중 쓰레드 프로그램에서 다소 긴 작업을 처리하는 작업쓰레드가 있고, 이 쓰레드에서 작업을 처리하는 동안 얼마만큼을
    처리했는지 처리과정을 나타내는 진행 상황 정보 변수를 담은 object 에 자주 조회해야 한다고 해보자.

    (물론, 진행 상황 정보 변수들이 동적할당이 필요없는 데이타라면 동기화가 굳이 필요없으므로, 여기서는 동적 할당이 필
    요한 변수들이 있다고 가정한다.)

        1) 작업쓰레드 object 에 주기적으로 polling 하는 경우,

    이때는 해당 작업쓰레드에서 진행 상황 정보 object 에 진행정보변수를 설정하거나, 다른 쓰레드에서 진행 상황 정보 object
    에 접근할 때에는 동기화를 해주어야 한다.

    진행상황정보의 읽기 작업(즉 polling)이 갱신작업보다 상당히 많다면 읽기/쓰기 lock 을 사용하는 것도 한 방법이다.

        2)  작업쓰레드 자체에서 실행 코드의 어떤 지점을 지날 때마다, 작업 진행 정보 object 를 인수로 하여, 어떤 지정된
            함수를 호출하는 경우,

    이처럼 작업 쓰레드 자체에서 주기적으로 어떤 함수를 호출하는 경우에는, 동기화가 필요없다. 단, 호출된 함수쪽 에서는
    경우에 따라 동기화할 필요가 있을 것이다.

    ※  진행 상황 정보 object 의 멤버 변수들이 불어나서 많아진다면 각각의 진행 상황 정보를 멤버 변수로 만드는 것 보다
        는 key/value 의 map 으로 구성하는 것도 좋을 것 같다. 이런 목적으로
    
        CKeyValueMap_T<> 이나 CKeyValMapPrgs(Sync)_T<>

    을 설계하였다.

    -- 2009-03-03 07:36:00

    ※  진행 상황 정보 object 의 멤버변수에 동작할당이 필요한 문자열이 있다면, 이 문자메모리를 동적으로 할당하지 말고
        문자 배열로 선언해서 사용할 수도 있겠다.

    -- 2009-03-05 06:20:00

■  서로 다른 다수의 오브젝트가, 다른 다수의 오브젝트에게 서로 다른 메시지를 송신해야 한다고 생각해보자. 각 클래스 인
    터페이스를 알아야 하고 그러기 위해서는 메시지를 수신하는 클래스의 헤더를, 송신하는 클래스에서 #include 해야 하고,
    또 수신하는 클래스에서 다시 송신하는 클래스에 메세지를 보낼때에는 양방향으로 #include 가 이루어져야 하는 등 포함
    관계가 아주 복잡해진다. 이것을 해결하기 위해

        class CKeyValueMap_T<   int,std::ZNsIFace::ZIDelgtMSG*,
                                int,std::ZNsIFace::ZIDelgtMSG*,
        /////////////////// >

    클래스를 설계한다. 이 클래스를 정적 object 로 갖는 클래스를 만들고, 이 클래스 헤더를 각각의 메시지 송/수신이 필요한
    클래스에서 #include 하면 된다. 이 다음 각 메시지 별로 std::ZNsIFace::ZIDelgtMSG 을 상속하는 클래스를 정의하여 사용하자.

    -- 2009-03-06 08:59:00

■  Modeless 대화상자에서 Modeless 대화상자를 호출한 부모 윈도우에서 쓰레드가 동작하고 있는 경우, 부모창이 닫히면 Modeless
    대화상자가 자동으로 안닫히는 경우가 있다. 이때는 부모창의 종료 이벤트에서 명시적으로 해당 Modeless 를 종료해 주는
    것이 좋다.

    -- 2009-03-08 21:28:00

■  함수 템플릿의 템플릿 인수가 템플릿인 경우에는 어떻게 전문화하는지, ZtCStringEx.H 의 ZNsMain::ZftMoveFast() 의 ZtCStringBase<>
    템플릿 전문화에 그 예가 있다.

    -- 2009-09-06 07:26:00

■  OS 별로 별도의 코딩이 필요한 파일들

    MainHead.H
    MainHeadEx.H

    CFileEx.H
    CProcess.H
    CNet.H

■  도전과 응전을 통한 발전 

    인간은 누구든 현실에 안주하려는 속성을 지니고 있다. 어느 정도의 단계에 이르면 거기에 만족하고 그만 멈추려 고 한다.
    그런데 인간이 처한 운명은 자꾸만 변하기 때문에 그럴 수가 없다. 운명은 인간에게 다음 단계로 올라가라고 도전장을 던
    진다. 그 단계에 이르면 다른 도전이 와서 또 다음 단계로 올라가게 한다. 그렇게 죽는 순간까지 인간은 도전을 받고 살아
    간다.

    - 아놀드 토인비 

    토인비는 가혹한 자연환경이나 외적의 침입 등 어느 문명권의 존속에 대한 위험을 도전으로 정의하고, 이러한 도전에 대하
    여 이들 문명권이 응전에 성공하면 그 문명권은 계속 존속 발전할 수 있고 응전에 실패하면 역사 속으로 사라진다고 주장
    합니다. 재미있는 사실은 도전을 받지 못한 문명 역시 멸망의 길을 걷는다는 것입니다. 문명은 아주 살기 어려운 환경에서
    발생하는 것이고, 살기 좋은 환경에서는 문명이 발생하지 않음을 알 수 있습니다. 

    http://phpschool.com/gnuboard4/bbs/board.php?bo_table=talkbox&wr_id=1473843&page=1

    -- 2009-04-28 09:16:00

■  템플릿 멤버 함수를 클래스 밖에서 정의하는 코드 예시.

    template<typename T> struct CShow
    {
        static void Show(){cout<<"## show : T="<<typeid(T).name()<<endl;}

        template<typename T2> static void Show2(T2);
    };

    template<typename T> template<typename T2>
    void CShow<T>::Show2(T2){cout<<"## show : T2="<<typeid(T2).name()<<endl;}

    -- 2013-05-06

■  main 함수의 반환값을 확인할 수 있다. 윈도우에서는 커맨드 라인에

        echo %ERRORLEVEL%
        
    명령을 입력하면 그 결과를 확인할 수 있고, 리눅스에서는 커맨드 라인에
    
        echo $?
        
    를 입력하면, 그 결과를 확인할 수 있다

    ☞ http://bcode.tistory.com/5

    -- 2011-03-03 22:43:00

■  아래 my1 과 my2 의 자료형은 서로 다르다.

    char        my1[]="C++ World1";
    const char* my2  ="C++ World2";

    cout<<typeid(my1).name()<<endl;
    cout<<typeid(my2).name()<<endl;

        my1 => char [11]
        my2 => char const * __ptr64

    -- 2025-08-21 12:42

■  코드 리뷰 체크 리스트 예. (김익환/전규현 著 '소프트웨어 개발의 모든 것' 167 page)

    □  리뷰자가 리뷰하고 있는 소스 코드를 이해하고 있는가?
    □  소스 코드가 회사의 코딩 표준을 준수하고 있는가?
    □  함수의 모든 인수가 입력용인지 출력용인지 명시되어 있는가?
    □  모든 복잡한 알고리즘에 대하여 설명이 있는가?
    □  주석 처리되어 사용되지 않은 소스 코드에 대하여, 주석 처리를 한 이유가 설명되어 있는가?
    □  정상적인 값이나 범위를 확인하기 위해서, 모든 데이타에 대하여 Assertion 을 사용하고 있는가?
    □  함수에서 리턴으로 나가는 모든 곳에서, 모든 에러를 적절히 처리하고 있는가?
    □  모든 Exception 을 제대로 처리하고 있는가?
    □  할당된 메모리를 모두 해제하고 있는가?
    □  모든 전역 변수가 thread-safe 한가?
    □  동시에 여러 쓰레드에서 액세스되는 모든 object 가 thread-safe 한가?
    □  모든 Lock 은 얻어진 순서대로 해제되고 있는가?
    □  무한 루프가 될만한 소스 코드는 없는가?
    □  소스 코드가 속도, 메모리 사용에 무리는 없는가?
    □  모든 배열의 인덱스가 배열의 크기를 넘어서 참조하지 않는가?
    □  모든 변수는 사용하기 전에 초기화하고 있는가?
    □  이미 존재하는 API 를 사용해서 대체할 수 있는 부분이 있는가?

    여기에 멀티 쓰레드에 관련된 항목만 뽑아내고, 몇 가지를 더 추가하자.

    □  모든 전역 변수가 thread-safe 한가?
    □  동시에 여러 쓰레드에서 액세스되는 모든 object 가 thread-safe 한가?
    □  모든 Lock 은 얻어진 순서대로 해제되고 있는가?
    □  무한 루프가 될만한 소스 코드는 없는가?

    □  동기화 영역에서 보호되는 class 의 멤버 변수는, 해당 동기화 object 와 가까운 곳에 선언되어 있는가?

        멀리 떨어져서 선언되어 있다면, 아주 골치아픈 문제가 발생할 수 있다. 이것은 아는 사람만 알 것이다.

    □  동기화 영역에서 수행되는 Flow 가 '정밀'하게 정리되어 있는가?

    -- 2011-04-16 15:39:00

    □  DB 에서 ERD 가 있는 것처럼, 클래스 설계도나 근거 자료가 있는가?

    -- 2011-04-17 12:08:00

    □  문자열의 길이와 파일 길이, 소켓 송수신 버퍼 길이를 표현하는 정수가 적절하게 typedef 되어 있고, 일관성있게 사용
        되고 있는가?

    -- 2011-05-09 21:10:00

    □  소켓 송수신 버퍼 길이를 표현하는 정수의 범위를 넘어서 송수신하는 경우는 없는가.
    □  정수의 overflow 나 underflow 는 없는가.

    -- 2011-05-19 09:14:00

    □  소켓 송신 시에 vector 와 관련 자료구조를 적절히 사용하여, 문자열 object 가 송신 버퍼 리스트에 전달될 때, 송신
        데이타의 복사가 최소화되도록 하였는가. 가급적 문자열 object 의 문자열 메모리가 송신 버퍼 리스트로 (복사가 아닌)
        이동되는 것이 좋으며, 때에 따라 송신 버퍼 리스트의 각 원소를 고정 길이 문자 배열로 구현하는 것도 좋을 수 있다.

    -- 2013-06-08 15:25:00

    □  작업 구간이 일부 겹치는 경우, 동적 메모리를 사용하는 멤버 변수에 접근할 때, 적절한 동기화가 되었는가.

    -- 2013-06-09 18:34:00

    □  스케줄러 쓰레드에 스케줄이 다중으로 등록되는 일은 없는가. '동해기계항공'에서 장비 모니터링 프로그램을 만들어
        줄 때, 스케줄이 점점 다중 등록되어서 시간 주기가 짧아지고 로그도 점점 커지는 경우가 있었다.

        또한 ABA 가 문제를 발생시키는 경우에도, 정확히 처리가 되는지 점검해야 한다.

    -- 2013-06-21 19:41:00

    □  하나의 object 가 다른 작업 쓰레드에서 접근하고 사용 중일 때, 해당 object 가 다른 요인에 의해서 소멸되지 않도
        록 되어 있는가. 이 때, 아래에서 설명하는 '참조 카운팅 종료'가 적용되면 좋다.

    -- 2013-06-23 19:30:00

    □  new[] 로 생성된 것은 delete[] 로 해제되고 있는가. 이것은 MainHead.H 의 2013-07-09 23:32:00 일자 주석을 참고.
        리눅스에서라면 valgrind 로 검사하는 것도 좋다. 여기까지 오는데 참 기나긴 시간이 흐르지 않았는가.

    -- 2013-07-09 23:44:00

        new 나 new[] 로 생성되는 일이 아예 없어야겠다. 즉 ZtCObjNew<> 나 CArray_T<> 등의 클래스 를 사용해야 한다.

    -- 2013-07-11 01:26:00

    □  네트워크 관련 처리에서, 데이타를 수신 버퍼로 수신하는 상황에서, 수신 버퍼의 최대 크기로 수신한 경우, 더 수신할
        데이타가 있는지 검사하였는가.

        이 사항은 MainSSL.H 의 2015-03-06 22:17:00 일자 기록을 참고. https://www.openssl.org 의 데이타를 가져올 때, 응
        답 본문을 BIO object 에서 읽어 왔는데, 최대 수신 버퍼 크기로 읽어 왔을 때의 처리가 빠져 있었다. 그래서 이상하게
        본문을 끝까지 받지 못했었다.

        -- 2015-03-08 21:32:00

    □  쓰레드풀 같이 object 의 풀을 사용하는 경우, object 을 풀에 반납하고 가져올 때, 종료및 초기화 처리가 되었는가.

        CCtrlAsyncSock.H 파일의 "'코드C2'에 대한 주석" 참고. -- 2015-03-22 17:01:00

■  참조 카운팅 종료

    object 의 참조 카운팅이 -1 인 경우에만, 어떤 object 를 소멸시키거나, 특정 flow 를 종료하는 것이다. 어떤 object 의
    참조를 다른 작업 쓰레드에서 사용하는 경우, 그 쓰레드에서 해당 object 에 접근하는 동안에는 다른 쓰레드에서 그 object
    를 소멸시키면 안된다. 이런 때 사용하는 기법이다.

    -- 2013-06-23 19:25:00

    '참조 카운팅 종료'시에 어떤 종료 행위를 효과적으로 수행하기 위해, 참조 카운팅을 증가/감소시키는 함수는 외부 object
    를 인수로 받아, 그 object 에서 일정한 행위를 수행하게 하면 좋다.

    -- 2013-06-23 19:34:00

■  'char 의 int 확장에 따른 문제의 코드'

    아래 함수에서

        int ZtCMainChars<>::Minus(TypeCharC*, TypeCharC*, TypeLength, TypeLength)

    return 문을

        return VC_Minus; // VC_Minus 는 *(VP_Left-1)-*(VP_Right-1)

    에서

        return int(*(VP_Left-1))-int(*(VP_Right-1));

    로 고쳤다. 컴파일러에 따라, 음수 char 을 int 로 확장하면 양수(+)가 될 수 있는 것이다. 이
    것을 언제 알았냐면, LG CNS 에서 충전기 프로젝트를 할 때다. 그때 ELDK 4.0 tool chain 의
    컴파일러를 사용했는데, NsUtility::CLoadSimUrlConfig_T<> 으로 설정 파일을 읽어들일 때, 자
    꾸 몇몇 설정값을 인식하지 못하고 있었다. CLoadSimUrlConfig_T<> 은 ns1.cppschool.com 과
    ns2.cppschool.com 에서 테스트된 클래스이다. 그런데도 이런 문제가 발생한 것이다. 이전에
    Hemose 의 메신저 서버를 만들 때에도 이런 문제가 있었는데, 풀리지 않을 것 같은 문제로 여
    기고 매우 긴장하고 있었다. CObjAVL.H 파일의 AddKey() 함수의 비교하는 부분에 cout 으로
    출력해 보니까, 항상 '>' 조건이 아닌가. 그래서 ZtCMainChars<>::Minus() 함수까지 파들어가
    리턴하는 값을 보니까 항상 양수였다! 이럴수가, 왼쪽이 작으면 음수를 리턴해야 한다. 그런
    데 항상 양수라니. 좀 더 조사해 보니까, 해당 컴파일러의, char 의 int 형 확장에 따른 문제
    였고 코드를 위처럼 고치게 되었다.

    -- 2011-12-29 17:35:00

■  g++ 에서 아래가 컴파일이 안 된다.


    #include<iostream>


    using namespace std;


    int Main(int AI_ArgCnt=0, const char* APP_ArgVal[]=0)
    {
        cout<<"Call Main()"<<endl;  return 0;
    }
    /////////////////////////////////////////////////////

    int main(int AI_ArgCnt, char* APP_ArgVal[])
    {
        return Main(AI_ArgCnt, APP_ArgVal);
    }
    ///////////////////////////////////////////


    □  mingw 컴파일

        g++.exe -o g++_test_000.exe   g++_test_000.cpp -I../

            Administrator@q381-2673 UCRT64 /e/my_CPP/ZCpp/ZCppMainTest
            # g++.exe -o g++_test_000.exe   g++_test_000.cpp -I../
            g++_test_000.cpp: In function 'int main(int, char**)':
            g++_test_000.cpp:18:28: error: invalid conversion from 'char**' to 'const cha
            r**' [-fpermissive]
               18 |     return Main(AI_ArgCnt, APP_ArgVal);
                  |                            ^~~~~~~~~~
                  |                            |
                  |                            char**
            g++_test_000.cpp:9:39: note:   initializing argument 2 of 'int Main(int, cons
            t char**)'
                9 | int Main(int AI_ArgCnt=0, const char* APP_ArgVal[]=0)
                  |                           ~~~~~~~~~~~~^~~~~~~~~~~~~~

        Administrator@q381-2673 UCRT64 /e/my_CPP/ZCpp/ZCppMainTest
        # g++ --version
        g++.exe (Rev2, Built by MSYS2 project) 13.2.0
        Copyright (C) 2023 Free Software Foundation, Inc.
        This is free software; see the source for copying conditions.  There is NO
        warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

    □  해결 방법-1

        #include<iostream>

        using namespace std;

        int Main(int AI_ArgCnt=0, const char* const APP_ArgVal[]=0)
        {
            cout<<"Call Main()"<<endl;  return 0;
        }
        ///////////////////////////////////////////////////////////

        int main(int AI_ArgCnt, char* APP_ArgVal[])
        {
            return Main(AI_ArgCnt, APP_ArgVal);
        }
        ///////////////////////////////////////////

    □  해결 방법-2

        #include<iostream>

        using namespace std;

        int Main(int AI_ArgCnt=0, char* const APP_ArgVal[]=0)
        {
            cout<<"Call Main()"<<endl;  return 0;
        }
        /////////////////////////////////////////////////////

        int main(int AI_ArgCnt, char* APP_ArgVal[])
        {
            return Main(AI_ArgCnt, (const char**)APP_ArgVal);
        }
        ///////////////////////////////////////////


    -- 2025-08-25 00:56

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



#endif //__ZCPPMAIIN_ZMAINHEAD_H__