admin/RepoMain
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
f7636ecc5df00738cff1b486a8507575ae5d8640
RepoMain/ZCppMain/ZtCArray.H
sauron f7636ecc5d commit 2025-08-16 34:34 
git add ZCppMain/ZMainHead.H
git add ZCppMain/ZtCArray.H
git add ZCppMain/ZtCObjList.H
git add ZCppMain/ZMainAVL.H
git add ZCppMain/ZMainHeadEx.H
git add ZCppMain/ZMainXhtml.H
git add ZCppMain/ZtCLoadDataBlock.H
git add ZCppMain/ZtCMainChars.H
git add ZCppMain/ZtCObjAVL.H
git add ZCppMain/ZtCStringEx.H
git add ZCppMain/ZtCTreeData.H
2025-08-16 23:35:44 +09:00

1170 lines
39 KiB
C++
Raw Blame History

#ifndef __ZCPPMAIIN__ZTCARRAY_H__
#define __ZCPPMAIIN__ZTCARRAY_H__
#include "ZCppMain/ZMainHead.H"
namespace ZNsMain
{
template< typename TType ,
typename TTypArg=const TType&,
typename TSize =long
>
class ZtCArray //////////////////////////
{
public:
typedef TType Type ;
typedef TType TypeData;
typedef TTypArg TypeArg ;
typedef TSize TypeSize;
typedef ZtCArray ZCArray ;
public:
class ZCIterator;
public:
typedef Type* IterEasy;
typedef ZCIterator iterator;
typedef const ZCIterator const_iterator;
public:
class ZCIterator
{
private: mutable
Type* mp_Data ; mutable
TSize ml_ElePos; // *mp_Data 가 배열에서 차지하는 위치
ZCArray* mp_CArray;
public:
ZCIterator()
{
mp_Data =0;
mp_CArray=0;
ml_ElePos=0;
}/*
ZCIterator()*/
ZCIterator(ZCArray& AR_CArray, Type& AR_CData, TSize AL_ElePos)
{
mp_Data =&AR_CData ;
mp_CArray=&AR_CArray;
ml_ElePos=AL_ElePos ;
}/*
ZCIterator(ZCArray& AR_CArray, Type& AR_CData, TSize AL_ElePos)*/
ZCIterator(ZCArray& AR_CArray)
{
mp_Data = AR_CArray.mp_TypeArr ;
mp_CArray=&AR_CArray ;
ml_ElePos=(AR_CArray.size()>0 ? 1 : 0 ) ;
}/*
ZCIterator(ZCArray& AR_CArray)*/
ZCIterator(const ZCArray& AR_CArray)
{
mp_Data = AR_CArray.mp_TypeArr;
mp_CArray=const_cast<ZCArray*>(&AR_CArray);
ml_ElePos=(AR_CArray.size()>0 ? 1 : 0 ) ;
}/*
ZCIterator(const ZCArray& AR_CArray)*/
Type& operator*( ){return *mp_Data;}
Type* operator->(){return mp_Data;}
const Type& operator* () const{return *mp_Data;}
const Type* operator->() const{return mp_Data;}
ZCIterator& operator++( ){++mp_Data; ++ml_ElePos; return *this;}
ZCIterator operator++(int){++mp_Data; ++ml_ElePos; return *this;}
const ZCIterator& operator++( ) const{++mp_Data; ++ml_ElePos; return *this;}
const ZCIterator operator++(int) const{++mp_Data; ++ml_ElePos; return *this;}
ZCIterator operator+(TSize AL_AddPos) const
{
return ZCIterator(*this, mp_Data+AL_AddPos, ml_ElePos+AL_AddPos);
}/*
ZCIterator operator+(TSize AL_AddPos) const*/
public:
};/*
class ZCIterator
public :*/
protected:
enum{ZEAddSize=20};
protected:
Type* mp_TypeArr ;
TypeSize ml_AllSize ;
TypeSize ml_UseSize ;
TypeSize ml_AddSize ;
/* TSize ml_AddSize 는 추가 메모리를 지정. 한 개의 원소가 삽입되서
재할당해야 할 경우, ml_AddSize 개 만큼을 미리 할당한다.
protected:*/
public :
ZtCArray()
{
mp_TypeArr =0;
ml_AllSize =0;
ml_UseSize =0;
ml_AddSize =ZEAddSize;
}/*
ZtCArray()*/
ZtCArray(const ZtCArray& rhs)
{
mp_TypeArr =0;
ml_AllSize =0;
ml_UseSize =0;
ml_AddSize =ZEAddSize;
*this=rhs;
}/*
ZtCArray(const ZtCArray& rhs)*/
~ZtCArray()
{
Delete();
}/*
~ZtCArray()*/
ZCArray& operator=(const ZCArray& rhs)
{
ReAlloc(rhs.ml_UseSize, false);
ml_UseSize=rhs.ml_UseSize;
ml_AllSize=rhs.ml_AllSize;
for(TypeSize i=0; i<ml_UseSize; ++i)
{
mp_TypeArr[i]=rhs.mp_TypeArr[i];
}/*
for(TypeSize i=0; i<ml_UseSize; ++i)*/
return *this;
}/*
ZCArray& operator=(const ZCArray& rhs)*/
ZCArray& operator()(TypeArg AR_TypeArg)
{
AddTail(AR_TypeArg); return *this;
}/*
ZCArray& operator()(TypeArg AR_TypeArg)*/
void Delete()
{
delete [] mp_TypeArr;
mp_TypeArr =0;
ml_AllSize =0;
ml_UseSize =0;
}/*
void Delete()*/
void clear()
{
Delete();
}/*
void clear()*/
TypeSize GetAllSize() const{return ml_AllSize;}
TypeSize GetUseSize() const{return ml_UseSize;}
TypeSize GetAddSize() const{return ml_AddSize;}
TypeSize size () const{return ml_UseSize;}
TypeSize capacity() const{return ml_AllSize;}
void SetAddSize(TypeSize AL_NewAddSize)
{
if(AL_NewAddSize>=1) ml_AddSize=AL_NewAddSize;
}/*
void SetAddSize(TypeSize AL_NewAddSize)*/
void SetUseSize(TypeSize AL_NewUseSize)
{
if(AL_NewUseSize>=0 && AL_NewUseSize<=ml_AllSize)
{
ml_UseSize=AL_NewUseSize;
}/*
if(AL_NewUseSize>=0 && AL_NewUseSize<=ml_AllSize)*/
}/*
void SetUseSize(TypeSize AL_NewUseSize)*/
void ReAlloc(TypeSize AL_AllocSize, bool AB_DoKeep=true)
{
if(AL_AllocSize<1) return ;
if(AL_AllocSize<ml_AllSize)
{
return ;
}
if(AL_AllocSize-ml_AllSize<ml_AddSize)
{
AL_AllocSize=ml_AllSize+ml_AddSize ;
}/*
if(AL_AllocSize-ml_AllSize<ml_AddSize)*/
if(mp_TypeArr==0)
{
mp_TypeArr =new Type[AL_AllocSize];
ml_AllSize =AL_AllocSize ;
return ;
}/*
if(mp_TypeArr==0)*/
if(AB_DoKeep)
{
Type* VP_ArrType=new Type[AL_AllocSize] ;
memcpy(VP_ArrType, mp_TypeArr, ml_AllSize*sizeof(Type));
delete [] mp_TypeArr; mp_TypeArr=VP_ArrType;
}
else
{
delete [] mp_TypeArr; mp_TypeArr=new Type[AL_AllocSize] ;
}/*
else*/
ml_AllSize=AL_AllocSize;
}/*
void ReAlloc(TypeSize AL_AllocSize, bool AB_DoKeep=true)*/
// cf) std::vecter<type>::assign(size_type _Count, const type&);
void assign(TypeSize AL_AllocSize, bool AB_DoKeep=true)
{
this->ReAlloc(AL_AllocSize, AB_DoKeep);
this->SetUseSize(AL_AllocSize);
}/*
void assign(TypeSize AL_AllocSize, bool AB_DoKeep=true)*/
Type& operator[](TypeSize AL_Index)
{
#ifdef _DEBUG
if(AL_Index>=ml_UseSize)
{
std::fstream fileout("DEBUG.txt",std::ios::out | std::ios::app);
fileout<<std::endl<<"File : "<<__FILE__<<std::endl<<"Line : "<<__LINE__<<std::endl;
fileout<<"Error In 'Type& operator[](TypeSize AL_Index)"<<std::endl;
fileout<<" AL_Index>=ml_UseSize"<<", "<<AL_Index<<">="<<ml_UseSize<<std::endl;
fileout.close();
::exit(1);
}/*
if(AL_Index>=ml_UseSize)*/
#endif //_DEBUG
return mp_TypeArr[AL_Index] ;
}/*
Type& operator[](TypeSize AL_Index)*/
const Type& operator[](TypeSize AL_Index) const
{
#ifdef _DEBUG
if(AL_Index>=ml_UseSize)
{
std::fstream fileout("DEBUG.txt", std::ios::out | std::ios::app);
fileout<<std::endl<<"File : "<<__FILE__<<std::endl<<"Line : "<<__LINE__<<std::endl;
fileout<<"Error In 'const Type& operator[](TypeSize AL_Index) const"<<std::endl;
fileout<<" AL_Index>=ml_UseSize"<<std::endl;
fileout.close();
::exit(1);
}/*
if(AL_Index>=ml_UseSize)*/
#endif //_DEBUG
return mp_TypeArr[AL_Index] ;
}/*
const Type& operator[](TypeSize AL_Index) const*/
Type& GetData(TypeSize AL_Index)
{
#ifdef _DEBUG
if(AL_Index>=ml_UseSize)
{
std::fstream fileout("DEBUG.txt",std::ios::out | std::ios::app);
fileout<<std::endl<<"File : "<<__FILE__<<std::endl<<"Line : "<<__LINE__<<std::endl;
fileout<<"Error In 'Type& GetData(TypeSize AL_Index)"<<std::endl;
fileout<<" AL_Index>=ml_UseSize"<<std::endl;
fileout.close();
::exit(1);
}/*
if(AL_Index>=ml_UseSize)*/
#endif //_DEBUG
return mp_TypeArr[AL_Index] ;
}/*
Type& GetData(TypeSize AL_Index)*/
const Type& GetData(TypeSize AL_Index) const
{
#ifdef _DEBUG
if(AL_Index>=ml_UseSize)
{
std::fstream fileout("DEBUG.txt",std::ios::out | std::ios::app);
fileout<<std::endl<<"File : "<<__FILE__<<std::endl<<"Line : "<<__LINE__<<std::endl;
fileout<<"Error In 'const Type& GetData(TypeSize AL_Index) const"<<std::endl;
fileout<<" AL_Index>=ml_UseSize"<<std::endl;
fileout.close();
::exit(1);
}/*
if(AL_Index>=ml_UseSize)*/
#endif //_DEBUG
return mp_TypeArr[AL_Index];
}/*
const Type& GetData(TypeSize AL_Index) const*/
void AddHead(TypeArg AR_TypeArg)
{
ReAlloc((ml_UseSize++)+1);
for(TypeSize i=ml_UseSize-2; i>=0; --i)
{
mp_TypeArr[i+1]=mp_TypeArr[i] ;
}/*
for(TypeSize i=ml_UseSize-2; i>=0; --i)*/
mp_TypeArr[0]=AR_TypeArg ;
}/*
void AddHead(TypeArg AR_TypeArg)*/
Type& AddHead()
{
// 앞에 빈 원소를 삽입하고 그 원소를 반환한다.
ReAlloc((ml_UseSize++)+1);
for(TypeSize i=ml_UseSize-2; i>=0; --i)
{
mp_TypeArr[i+1]=mp_TypeArr[i] ;
}/*
for(TypeSize i=ml_UseSize-2; i>=0; --i)*/
return mp_TypeArr[0] ;
}/*
Type& AddHead()*/
void AddTail(TypeArg AR_TypeArg)
{
ReAlloc((ml_UseSize++)+1); mp_TypeArr[ml_UseSize-1]=AR_TypeArg ;
}/*
void AddTail(TypeArg AR_TypeArg)*/
Type& AddTail()
{
// 끝에 빈 원소를 삽입하고 그 원소를 반환한다.
ReAlloc((ml_UseSize++)+1); return mp_TypeArr[ml_UseSize-1];
}/*
Type& AddTail()*/
operator Type&()
{
return AddTail();
}/*
operator Type&()*/
void push_back(TypeArg AR_TypeArg)
{
AddTail(AR_TypeArg);
}/*
void push_back(TypeArg AR_TypeArg)*/
Type& push_back()
{
return AddTail();
}/*
Type& push_back()*/
ZCIterator begin()
{
return ZCIterator(*this);
}/*
ZCIterator begin()*/
const ZCIterator begin() const
{
return ZCIterator(*this);
}/*
const ZCIterator begin() const*/
template<typename TFunctor> void IterElement(TFunctor AO_Functor)
{
Type* VP_TypeArr = mp_TypeArr;
__for0(TypeSize, i, ml_UseSize)
{
ZNsMain::ZtCTypeData<TFunctor>::
GetObjRef(AO_Functor)( *VP_TypeArr );
++VP_TypeArr;
/* ZtCTypeData 으로 인해서, AO_Functor 이 함수일 때뿐이 아니라,
operator() 연산자를 가진 object 포인터일 때도 사용할 수 있게 되었다. */
}/*
__for0(TypeSize, i, ml_UseSize)*/
}/*
template<typename TFunctor> void IterElement(TFunctor AO_Functor)*/
template<typename TFunctor, typename TTypeHelp>
void IterElement(TFunctor AO_Functor, TTypeHelp AO_TypeHelp)
{
/*/////////////////////////////////////////////////////////////////////////////
■ TTypeHelp 가 class 일 경우, 크기가 커서 참조로 넘어가야 한다면,
IterElement<myFunctor, myClass&>(myFunctor_obj, myClass_Obj);
의 형태로 호출할 게 아니라, ZNsMain::ZtCObjectPtr<> 을 사용하여,
myClass myClass_Obj;
ZNsMain::ZtCObjectPtr<myClass> myCObjPtr(myClass_Obj);
나
IterElement(myFunctor_obj,
ZNsMain::ZtCObjectPtr<myClass>(myClass_Obj));
형태를 사용하면 좋을 것 같다. -- 2014-06-16 23:11:00
ZCCheckRef::PassData() 으로 인해, 인수를 ZtCRef 클래스를 이용해 인수를 참조
로 넘길 수 있게 되었다. -- 2021-03-10 16:56
이제는 ZtCRef 과 ZCCheckRef 클래스 템플릿을 사용하면 된다. -- 2021-03-11 11:00
이제는 ZftMCR() 과 ZftMCP() 을 사용하면 된다. -- 2025-08-07 17:55
■ 예제1 -- 2025-08-07 17:35
#include <iostream>
#include "ZCppMain/ZtCArray.H"
using namespace std ;
using namespace ZNsMain;
int main()
{
ZtCArray<int> myArray;
myArray.AddTail(10);
myArray.AddTail(20);
myArray.AddTail(30);
myArray.AddTail(40);
class CHelpObj
{
public:
CHelpObj()
{
}
CHelpObj(const CHelpObj& rhs)
{
cout<<"* CHelpObj(const CHelpObj& rhs)"<<endl;
}
public:
}; CHelpObj VO_CHelpObj; cout<<"VO_CHelpObj Ptr : "<<&VO_CHelpObj<<endl;
struct StFunctor
{
static void ShowElement(int ArgiValue){cout<<"#1 Value="<<ArgiValue<<endl;}
};
struct StFunctor2
{
static void ShowElement(int ArgiValue, CHelpObj)
{cout<<"#2 Value="<<ArgiValue<<", CHelpObj Addr=None"<<" With CHelpObj"<<endl;}
};
struct StFunctor3
{
static void ShowElement(int ArgiValue, CHelpObj& AR_CHelpObj)
{cout<<"#3 Value="<<ArgiValue<<", HelpObj Ptr="<<&AR_CHelpObj<<" With CHelpObj Ref"<<endl;}
};
struct StFunctor4
{
static void ShowElement(int ArgiValue, CHelpObj& AR_CHelpObj)
{cout<<"#4 Value="<<ArgiValue<<", HelpObj Ptr="<<&AR_CHelpObj<<" With CHelpObj in Ptr"<<endl;}
};
struct StFunctor5
{
static void ShowElement(int ArgiValue, CHelpObj& AR_CHelpObj, CHelpObj& AR_CHelpObj2)
{cout<<"#5 Value="<<ArgiValue<<", HelpObj Ptr="<<&AR_CHelpObj<<" With CHelpObj Ref 2"<<endl;}
};
struct StFunctor6
{
static void ShowElement(int ArgiValue, CHelpObj& AR_CHelpObj, CHelpObj AO_CHelpObj2)
{cout<<"#6 Value="<<ArgiValue<<", HelpObj Ptr="<<&AR_CHelpObj<<" With CHelpObj Half Ref"<<endl;}
};
myArray.IterElement(StFunctor ::ShowElement);
myArray.IterElement(StFunctor2::ShowElement, VO_CHelpObj );
myArray.IterElement(StFunctor3::ShowElement, ZftMCR(VO_CHelpObj) );
myArray.IterElement(StFunctor4::ShowElement, ZftMCP(VO_CHelpObj) );
myArray.IterElement(StFunctor5::ShowElement, ZftMCP(VO_CHelpObj), ZftMCP(VO_CHelpObj) );
myArray.IterElement(StFunctor6::ShowElement, ZftMCP(VO_CHelpObj), VO_CHelpObj );
return 0;
}
/////////////////////////////////////////////////////////////////////////////*/
typedef ZNsMain::
ZtCCheckRef<TTypeHelp> ZCCheckRef;
Type* VP_TypeArr = mp_TypeArr;
__for0(TypeSize, i, ml_UseSize)
{
ZNsMain::ZtCTypeData<TFunctor>::GetObjRef(AO_Functor)
(
*VP_TypeArr, ZCCheckRef::PassData(AO_TypeHelp)
);
++VP_TypeArr; ///////////////////////////////////////
}/*
__for0(TypeSize, i, ml_UseSize)*/
}/*
template<typename TFunctor, typename TTypeHelp>
void IterElement(TFunctor AO_Functor, TTypeHelp AO_TypeHelp)*/
template<typename TFunctor, typename TTypeHelp1, typename TTypeHelp2>
void IterElement(TFunctor AO_Functor, TTypeHelp1 AO_TypeHelp1, TTypeHelp2 AO_TypeHelp2)
{
/*/////////////////////////////////////////////////////////////////////////////
■ TTypeHelp 가 class 일 경우, 크기가 커서 참조로 넘어가야 한다면,
IterElement<myFunctor, myClass&>(myFunctor_obj, myClass_Obj);
의 형태로 호출할 게 아니라, ZNsMain::ZtCObjectPtr<> 을 사용하여,
myClass myClass_Obj; ZNsMain::ZtCObjectPtr<myClass> myCObjPtr(myClass_Obj);
나
IterElement(myFunctor_obj, ZNsMain::ZtCObjectPtr<myClass>(myClass_Obj));
형태를 사용하면 좋을 것 같다. -- 2014-06-16 23:11:00
ZCCheckRef::PassData() 으로 인해, 인수를 ZtCRef 클래스를 이용해 인수를 참조
로 넘길 수 있게 되었다. -- 2021-03-10 16:56
이제는 ZtCRef 과 ZCCheckRef 클래스 템플릿을 사용하면 된다. -- 2021-03-11 11:00
/////////////////////////////////////////////////////////////////////////////*/
typedef ZNsMain::ZtCCheckRef<TTypeHelp1> ZCCheckRef1;
typedef ZNsMain::ZtCCheckRef<TTypeHelp2> ZCCheckRef2;
Type* VP_TypeArr = mp_TypeArr;
__for0(TypeSize, i, ml_UseSize)
{
ZNsMain::ZtCTypeData<TFunctor>::GetObjRef(AO_Functor)
(
*VP_TypeArr
, ZCCheckRef1::PassData(AO_TypeHelp1)
, ZCCheckRef2::PassData(AO_TypeHelp2)
);
++VP_TypeArr; ///////////////////////////////////////
}/*
__for0(TypeSize, i, ml_UseSize)*/
}/*
template<typename TFunctor, typename TTypeHelp1, typename TTypeHelp2>
void IterElement(TFunctor AO_Functor, TTypeHelp1 AO_TypeHelp1, TTypeHelp2 AO_TypeHelp2)*/
/*///////////////////////////////////////////////////////////////////////////
■ IterElement() 예제.
#include <iostream>
#include "ZCppMain/ZtCArray.H"
using namespace std ;
using namespace ZNsMain;
int main()
{
typedef ZtCArray<int> CArray ;
typedef CArray::IterEasy IterEasy;
CArray VO_Array;
VO_Array.AddTail(10);
VO_Array.AddTail(20);
VO_Array.AddTail(30);
VO_Array.AddTail(40);
class CHelpObj
{
public:
CHelpObj()
{
}
CHelpObj(const CHelpObj& rhs)
{
cout<<"* CHelpObj(const CHelpObj& rhs)"<<endl;
}
public:
}; CHelpObj VO_CHelpObj; cout<<"VO_CHelpObj Ptr : "<<&VO_CHelpObj<<endl;
struct StFunctor
{
static void ShowElement(int ArgiValue){cout<<"#1 Value="<<ArgiValue<<endl;}
};
struct StFunctor2
{
static void ShowElement(int ArgiValue, CHelpObj)
{cout<<"#2 Value="<<ArgiValue<<", CHelpObj Addr=None"<<" With CHelpObj"<<endl;}
};
struct StFunctor3
{
static void ShowElement(int ArgiValue, CHelpObj& AR_CHelpObj)
{cout<<"#3 Value="<<ArgiValue<<", HelpObj Ptr="<<&AR_CHelpObj<<" With CHelpObj Ref"<<endl;}
};
struct StFunctor4
{
static void ShowElement(int ArgiValue, CHelpObj& AR_CHelpObj)
{cout<<"#4 Value="<<ArgiValue<<", HelpObj Ptr="<<&AR_CHelpObj<<" With CHelpObj in Ptr"<<endl;}
};
struct StFunctor5
{
static void ShowElement(int ArgiValue, CHelpObj& AR_CHelpObj, CHelpObj& AR_CHelpObj2)
{cout<<"#5 Value="<<ArgiValue<<", HelpObj Ptr="<<&AR_CHelpObj<<" With CHelpObj Ref 2"<<endl;}
};
struct StFunctor6
{
static void ShowElement(int ArgiValue, CHelpObj& AR_CHelpObj, CHelpObj AO_CHelpObj2)
{cout<<"#6 Value="<<ArgiValue<<", HelpObj Ptr="<<&AR_CHelpObj<<" With CHelpObj Half Ref"<<endl;}
};
VO_Array.IterElement(StFunctor ::ShowElement);
VO_Array.IterElement(StFunctor2::ShowElement, VO_CHelpObj );
VO_Array.IterElement(StFunctor3::ShowElement, ZftMCR(VO_CHelpObj) );
VO_Array.IterElement(StFunctor4::ShowElement, ZftMCP(VO_CHelpObj) );
VO_Array.IterElement(StFunctor5::ShowElement, ZftMCP(VO_CHelpObj), ZftMCP(VO_CHelpObj) );
VO_Array.IterElement(StFunctor6::ShowElement, ZftMCP(VO_CHelpObj), VO_CHelpObj );
IterEasy VH_Iter = VO_Array.ItHEasy();
__for1(int, i, VO_Array.size())
{
cout<<i<<"th value="<<VO_Array.ItD(VH_Iter)<<endl; VO_Array.ItNext(VH_Iter);
}
return 0;
}
■ -- 2025-08-07 18:03:00
///////////////////////////////////////////////////////////////////////////*/
/*///////////////////////////////////////////////////////////////////////////
■ 순차적으로 각 원소를 순회할 수 있는 자료 구조, 즉 리스트나 배열 클래스는
MoveNextIter(), MovePrevIter()
멤버를 갖는 것으로 정했다. stl 의 반복자는 너무 일반화하다보니, 성능 상의
제약이 발생한 것 같다.
-- 2011-06-07 20:25:00
GetDataInIter() 를 추가했다.
-- 2011-06-12 20:42:00
///////////////////////////////////////////////////////////////////////////*/
Type* GetHeadIterEasy (){return mp_TypeArr ;}
Type* GetTailIterEasy (){return mp_TypeArr+ml_UseSize-1 ;}
IterEasyID GetHeadIterEasyID(){return (IterEasyID) mp_TypeArr ;}
IterEasyID GetTailIterEasyID(){return (IterEasyID)(mp_TypeArr+ml_UseSize-1);}
const Type* GetHeadIterEasy () const{return mp_TypeArr ;}
const Type* GetTailIterEasy () const{return mp_TypeArr+ml_UseSize-1 ;}
const IterEasyID GetHeadIterEasyID() const{return (IterEasyID) mp_TypeArr ;}
const IterEasyID GetTailIterEasyID() const{return (IterEasyID)(mp_TypeArr+ml_UseSize-1);}
void MoveNextIter(Type*& APR_CType ) const{++APR_CType ;}
void MoveNextIter(iterator& ARR_CIterator) const{++ARR_CIterator;}
void MoveNextIter(IterEasyID& AI_IterEasyID) const
{ MoveNextIter((Type*&)AI_IterEasyID); }
void MoveNextIter(const Type*& APR_CType ) const{++APR_CType ;}
void MoveNextIter(const iterator& ARR_CIterator) const{++ARR_CIterator;}
void MoveNextIter(const IterEasyID& AI_IterEasyID)
const{ MoveNextIter((const Type*&)AI_IterEasyID); }
void MovePrevIter(Type*& APR_CType ) const{--APR_CType ;}
void MovePrevIter(iterator& ARR_CIterator) const{--ARR_CIterator;}
void MovePrevIter(IterEasyID& AI_IterEasyID) const
{ MovePrevIter((Type*&)AI_IterEasyID); }
void MovePrevIter(const Type*& APR_CType ) const{--APR_CType ;}
void MovePrevIter(const iterator& ARR_CIterator) const{--ARR_CIterator;}
void MovePrevIter(const IterEasyID& AI_IterEasyID)
const{ MovePrevIter((const Type*&)AI_IterEasyID); }
Type& GetDataInIter(Type* AP_CType ){return *AP_CType ;}
Type& GetDataInIter(iterator& ARR_CIterator){return *ARR_CIterator ;}
Type& GetDataInIter(IterEasyID AI_IterEasyID){return *(Type*)AI_IterEasyID;}
const Type& GetDataInIter(const Type* AP_CType ) const{return *AP_CType;}
const Type& GetDataInIter(const iterator& ARR_CIterator) const{return *ARR_CIterator;}
const Type& GetDataInIter(const IterEasyID AI_IterEasyID) const
{ return *(const Type*)AI_IterEasyID; }
Type& GetDataInIter(Type* AP_Type , TypeSize AI_FarNum)
{ return *(AP_Type + AI_FarNum) ; }
Type& GetDataInIter(iterator& ARR_CIterator , TypeSize AI_FarNum)
{ return *(ARR_CIterator+AI_FarNum) ; }
Type& GetDataInIter(IterEasyID ARRI_IterEasyID, TypeSize AI_FarNum)
{ return GetDataInIter((Type*)ARRI_IterEasyID, AI_FarNum); }
const Type& GetDataInIter(const Type* AP_Type , TypeSize AI_FarNum) const
{ return *(AP_Type + AI_FarNum); }
const Type& GetDataInIter(iterator& ARR_CIterator, TypeSize AI_FarNum) const
{ return *(ARR_CIterator+AI_FarNum); }
const Type& GetDataInIter(const IterEasyID ARRI_IterEasyID, TypeSize AI_FarNum) const
{ return GetDataInIter((const Type*)ARRI_IterEasyID, AI_FarNum); }
Type* ItHEasy (){return mp_TypeArr ;}
Type* ItTEasy (){return mp_TypeArr+ml_UseSize-1 ;}
IterEasyID ItHID(){return (IterEasyID) mp_TypeArr ;}
IterEasyID ItTID(){return (IterEasyID)(mp_TypeArr+ml_UseSize-1);}
const Type* ItHEasy () const{return mp_TypeArr ;}
const Type* ItTEasy () const{return mp_TypeArr+ml_UseSize-1 ;}
const IterEasyID ItHID() const{return (IterEasyID) mp_TypeArr ;}
const IterEasyID ItTID() const{return (IterEasyID)(mp_TypeArr+ml_UseSize-1);}
void ItNext(Type*& APR_CType ) const{++APR_CType ;}
void ItNext(iterator& ARR_CIterator) const{++ARR_CIterator;}
void ItNext(IterEasyID& AI_IterEasyID) const
{ ItNext((Type*&)AI_IterEasyID); }
void ItNext(const Type*& APR_CType ) const{++APR_CType ;}
void ItNext(const iterator& ARR_CIterator) const{++ARR_CIterator;}
void ItNext(const IterEasyID& AI_IterEasyID)
const{ ItNext((const Type*&)AI_IterEasyID); }
void ItPrev(Type*& APR_CType ) const{--APR_CType ;}
void ItPrev(iterator& ARR_CIterator) const{--ARR_CIterator;}
void ItPrev(IterEasyID& AI_IterEasyID) const
{ ItPrev((Type*&)AI_IterEasyID); }
void ItPrev(const Type*& APR_CType ) const{--APR_CType ;}
void ItPrev(const iterator& ARR_CIterator) const{--ARR_CIterator;}
void ItPrev(const IterEasyID& AI_IterEasyID)
const{ ItPrev((const Type*&)AI_IterEasyID); }
Type& ItD(Type* AP_Type ){return GetDataInIter(AP_Type );}
Type& ItD(iterator& ARR_CIterator ){return GetDataInIter(ARR_CIterator );}
Type& ItD(IterEasyID ARRI_IterEasyID ){return GetDataInIter(ARRI_IterEasyID );}
Type& ItD(Type* AP_Type , TypeSize AI_FarNum){return GetDataInIter(AP_Type , AI_FarNum );}
Type& ItD(iterator& ARR_CIterator , TypeSize AI_FarNum){return GetDataInIter(ARR_CIterator , AI_FarNum);}
Type& ItD(IterEasyID ARRI_IterEasyID, TypeSize AI_FarNum){return GetDataInIter(ARRI_IterEasyID, AI_FarNum);}
const Type& ItD(const Type* AP_Type ) const{return GetDataInIter(AP_Type );}
const Type& ItD(const iterator& ARR_CIterator ) const{return GetDataInIter(ARR_CIterator );}
const Type& ItD(const IterEasyID ARRI_IterEasyID ) const{return GetDataInIter(ARRI_IterEasyID );}
const Type& ItD(const Type* AP_Type , TypeSize AI_FarNum) const{return GetDataInIter(AP_Type );}
const Type& ItD(const iterator& ARR_CIterator , TypeSize AI_FarNum) const{return GetDataInIter(ARR_CIterator , AI_FarNum);}
const Type& ItD(const IterEasyID ARRI_IterEasyID, TypeSize AI_FarNum) const{return GetDataInIter(ARRI_IterEasyID, AI_FarNum);}
public:
};/*
template< typename TType ,
typename TTypArg=const TType&,
typename TSize =long
>
class ZtCArray /////////////////////////*/
//////////////////////////////////////////////
////////////// end class ZCArray //////////////
//////////////////////////////////////////////
/*////////////////////////////////////////////////////////////////////
■ class ZtCArrayOut<> 는 배열 메모리를 자체 할당하지 않고,
이미 외부에서 new 나 정적으로 선언되어 있는 배열을 사용한다.
따라서 ZtCArrayOut<> 내부에서 임의로 배열 크기를 조절할 수 없다.
-- 2011-08-05 20:40:00
////////////////////////////////////////////////////////////////////*/
template< typename TType,
typename TSize=long
>
class ZtCArrayOut /////////////
{
public:
typedef TType Type ;
typedef Type TypeData;
public:
typedef const Type* const_iterator;
typedef Type* iterator;
private:
Type* mp_TypeArr;
TSize ml_UseSize;
public:
ZtCArrayOut()
{
Init(0, 0);
}
ZtCArrayOut(TypeData* AP_DataArr, TSize AL_ArrSize)
{
Init(AP_DataArr, AL_ArrSize);
}
void Init(TypeData* AP_DataArr, TSize AL_ArrSize)
{
mp_TypeArr=AP_DataArr;
ml_UseSize=AL_ArrSize;
}/*
void Init(TypeData* AP_DataArr,TSize AL_ArrSize)*/
TSize size() const{return ml_UseSize;}
Type& operator[](TSize AL_Index)
{
#ifdef _DEBUG
if(AL_Index>=ml_UseSize)
{
std::fstream fileout("DEBUG.txt",std::ios::out | std::ios::app);
fileout<<std::endl<<"File : "<<__FILE__<<std::endl<<"Line : "<<__LINE__<<std::endl;
fileout<<"Error In 'Type& operator[](TSize AL_Index)"<<std::endl;
fileout<<" AL_Index>=ml_UseSize"<<", "<<AL_Index<<">="<<ml_UseSize<<std::endl;
fileout.close();
::exit(1);
}/*
if(AL_Index>=ml_UseSize)*/
#endif //_DEBUG
return mp_TypeArr[AL_Index] ;
}/*
Type& operator[](TSize AL_Index)*/
const Type& operator[](TSize AL_Index) const
{
#ifdef _DEBUG
if(AL_Index>=ml_UseSize)
{
std::fstream fileout("DEBUG.txt",std::ios::out | std::ios::app);
fileout<<std::endl<<"File : "<<__FILE__<<std::endl<<"Line : "<<__LINE__<<std::endl;
fileout<<"Error In 'const Type& operator[](TSize AL_Index) const"<<std::endl;
fileout<<" AL_Index>=ml_UseSize"<<std::endl;
fileout.close();
::exit(1);
}/*
if(AL_Index>=ml_UseSize)*/
#endif //_DEBUG
return mp_TypeArr[AL_Index] ;
}/*
const Type& operator[](TSize AL_Index) const*/
Type& GetData(TSize AL_Index)
{
#ifdef _DEBUG
if(AL_Index>=ml_UseSize)
{
std::fstream fileout("DEBUG.txt",std::ios::out | std::ios::app);
fileout<<std::endl<<"File : "<<__FILE__<<std::endl<<"Line : "<<__LINE__<<std::endl;
fileout<<"Error In 'Type& GetData(TSize AL_Index)"<<std::endl;
fileout<<" AL_Index>=ml_UseSize"<<std::endl;
fileout.close();
::exit(1);
}/*
if(AL_Index>=ml_UseSize)*/
#endif //_DEBUG
return mp_TypeArr[AL_Index] ;
}/*
Type& GetData(TSize AL_Index)*/
const Type& GetData(TSize AL_Index) const
{
#ifdef _DEBUG
if(AL_Index>=ml_UseSize)
{
std::fstream fileout("DEBUG.txt",std::ios::out | std::ios::app);
fileout<<std::endl<<"File : "<<__FILE__<<std::endl<<"Line : "<<__LINE__<<std::endl;
fileout<<"Error In 'const Type& GetData(TSize AL_Index) const"<<std::endl;
fileout<<" AL_Index>=ml_UseSize"<<std::endl;
fileout.close();
::exit(1);
}/*
if(AL_Index>=ml_UseSize)*/
#endif //_DEBUG
return mp_TypeArr[AL_Index];
}/*
const Type& GetData(TSize AL_Index) const*/
Type* begin() { return mp_TypeArr; }
const Type* begin() const { return mp_TypeArr; }
void MoveNextIter(Type*& ARR_CIterator) const
{
++ARR_CIterator;
}/*
void MoveNextIter(Type*& ARR_CIterator) const*/
void MovePrevIter(iterator& ARR_CIterator)
{
--ARR_CIterator;
}/*
void MovePrevIter(iterator& ARR_CIterator)*/
void MoveNextIter(const_iterator& ARR_CIterator) const
{
++ARR_CIterator;
}/*
void MoveNextIter(const_iterator& ARR_CIterator) const*/
void MovePrevIter(const_iterator& ARR_CIterator) const
{
--ARR_CIterator;
}/*
void MovePrevIter(const_iterator& ARR_CIterator) const*/
/*////////////////////////////////////////////////////
위 코드를 아래로 하면 안된다.
void MoveNextIter(const iterator& ARR_CIterator) const
{
++ARR_CIterator;
}
//void MoveNextIter(const iterator& ARR_CIterator) const
void MovePrevIter(const iterator& ARR_CIterator) const
{
--ARR_CIterator;
}
//void MovePrevIter(const iterator& ARR_CIterator) const
const iterator 는 Type const * const 이지 Type const * 가 아니다.
-- 2011-08-05 23:49:00
////////////////////////////////////////////////////*/
Type& GetDataInIter(iterator& ARR_CIterator)
{
return *ARR_CIterator;
}/*
Type& GetDataInIter(iterator& ARR_CIterator)*/
const Type& GetDataInIter(const_iterator& ARR_CIterator) const
{
return *ARR_CIterator;
}/*
const Type& GetDataInIter(const_iterator& ARR_CIterator) const*/
public:
};/*
template< typename TType,
typename TSize=long
>
class ZtCArrayOut ///////////*/
template< typename TTypeOjb, ZTypLong ATI_Length=1
>
class ZtCArrayStack //////////////////////////////
{
public :
typedef TTypeOjb TypeData ;
typedef ZTypLong TypeSize ;
public :
enum{ EAllSize=ATI_Length } ;
private:
TypeData moa_Data[ATI_Length] ;
TypeSize ml_UseSize ; // moa_Data 의 실제 사용 길이
public :
ZtCArrayStack(TypeSize AL_StackSize)
{
ml_UseSize = 0;
}/*
ZtCArrayStack(TypeSize AL_StackSize)*/
ZtCArrayStack& operator=(const ZtCArrayStack& rhs)
{
clear(); return (*this)(rhs.data(),rhs.size());
}/*
ZtCArrayStack& operator=(const ZtCArrayStack& rhs)*/
ZtCArrayStack& operator()(const TypeData* AP_Data, TypeSize AL_Length)
{
if(AL_Length<1){ return *this; }
if(AL_Length+ml_UseSize > EAllSize)
{
AL_Length = EAllSize - ml_UseSize;
if(AL_Length<1) return *this;
}/*
if(AL_Length+ml_UseSize > EAllSize)*/
TypeData* VP_Dest= moa_Data+ml_UseSize; const
TypeData* VP_Src = AP_Data ;
ml_UseSize += AL_Length ;
while(--AL_Length>=0)
*VP_Dest++ = *VP_Src++ ;
*VP_Dest=0; return *this;
}/*
ZtCArrayStack& operator()(const TypeData* AP_Data, TypeSize AL_Length)*/
TypeSize GetSize() const
{
return ml_UseSize;
}/*
TypeSize GetSize() const*/
TypeSize GetEmptySize() const
{
return EAllSize - ml_UseSize ;
}/*
TypeSize GetEmptySize() const*/
TypeData* GetData()
{
return moa_Data;
}/*
TypeData* GetData()*/
const TypeData* GetData() const
{
return moa_Data;
}/*
const TypeData* GetData() const*/
void MemCopy(TypeData* AP_Data, TypeSize AL_Length)
{
if(AL_Length<1 || ml_UseSize<1)
return;
if(AL_Length>=ml_UseSize )
::memcpy(AP_Data, moa_Data, sizeof(TypeData)*ml_UseSize);
else
::memcpy(AP_Data, moa_Data, sizeof(TypeData)*AL_Length );
//else
}/*
void MemCopy(TypeData* AP_Data, TypeSize AL_Length)*/
TypeSize size() const
{
return ml_UseSize;
}/*
TypeSize size() const*/
TypeData* data()
{
return moa_Data;
}/*
TypeData* data()*/
const TypeData* data() const
{
return moa_Data;
}/*
const TypeData* data() const*/
void clear()
{
// add codes
}/*
void clear()*/
public:
};/*
template< typename TTypeOjb, typename ZTypLong ATI_Length=1
>
class ZtCArrayStack /////////////////////////////////////*/
}/*
namespace ZNsMain*/
#endif //__ZCPPMAIIN__ZTCARRAY_H__
Reference in New Issue View Git Blame Copy Permalink