1134 lines
39 KiB
C++
1134 lines
39 KiB
C++
|
|
|
|
#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 ;
|
|
public:
|
|
class ZCNodePoint; class ZCNodePointN ;
|
|
public:
|
|
typedef TypeData* IterEasy ;
|
|
typedef TypeData* TypeNode ; // ZCLinkPoint::GetNode() 의 반환형.
|
|
typedef ZCNodePoint TypeIter ;
|
|
typedef ZtCArray TypeThis ;
|
|
|
|
typedef const TypeThis TypeThisC ;
|
|
typedef const TypeData TypeDataC ;
|
|
typedef const TypeNode TypeNodeC ; // ZCLinkPoint::GetNode() const 의 반환형.
|
|
typedef const TypeIter TypeIterC ;
|
|
typedef const IterEasy IterEasyC ;
|
|
|
|
/**********************************************/
|
|
typedef const ZCNodePoint ZCNodePointC;
|
|
typedef const ZCNodePoint iteratorC ;
|
|
/**********************************************/
|
|
typedef ZCNodePoint iterator ;
|
|
typedef ZCNodePointN const_iterator;
|
|
typedef ZCNodePointN iteratorN ;
|
|
typedef ZCNodePointN TypeIterN ;
|
|
public:
|
|
|
|
|
|
class ZCNodePoint
|
|
{
|
|
private:
|
|
ZtCArray& mr_CArray; mutable
|
|
TypeData* mp_Data ; mutable
|
|
TypeSize ml_ElePos; // *mp_Data 가 배열에서 차지하는 위치
|
|
public:
|
|
|
|
static ZCNodePoint MakeTailPoint(ZtCArray & AR_CArray)
|
|
{
|
|
ZCNodePoint VO_ZCLinkPoint(AR_CArray);
|
|
|
|
if(AR_CArray.size()>0) /****************************/
|
|
{
|
|
VO_ZCLinkPoint.mp_Data = AR_CArray.mp_TypeArr+AR_CArray.size()-1 ;
|
|
VO_ZCLinkPoint.ml_ElePos = AR_CArray.size() ;
|
|
}
|
|
return VO_ZCLinkPoint; /****************************/
|
|
}/*
|
|
static ZCNodePoint MakeTailPoint(ZtCArray & AR_CArray)*/
|
|
static ZCNodePoint MakeTailPoint(TypeIterC& AR_TypeIter)
|
|
{
|
|
ZCNodePoint VO_ZCLinkPoint(AR_TypeIter);
|
|
|
|
const TypeSize VL_ArrSize = AR_TypeIter.mr_CArray.size();
|
|
|
|
if(VL_ArrSize>0) /**********************************/
|
|
{
|
|
VO_ZCLinkPoint.mp_Data = AR_TypeIter.mr_CArray+VL_ArrSize-1 ;
|
|
VO_ZCLinkPoint.ml_ElePos = VL_ArrSize ;
|
|
}
|
|
return VO_ZCLinkPoint; /****************************/
|
|
}/*
|
|
static ZCNodePoint MakeTailPoint(TypeIterC& AR_TypeIter)*/
|
|
|
|
public:
|
|
|
|
ZCNodePoint(ZtCArray& AR_CArray, Type& AR_CData, TSize AL_ElePos) :
|
|
mr_CArray(AR_CArray)
|
|
/*****************************************************************/
|
|
{
|
|
mp_Data =&AR_CData ;
|
|
ml_ElePos=AL_ElePos ;
|
|
}/*
|
|
ZCNodePoint(ZtCArray& AR_CArray, Type& AR_CData, TSize AL_ElePos)*/
|
|
|
|
ZCNodePoint(ZtCArray& AR_CArray) : mr_CArray(AR_CArray)
|
|
{
|
|
mp_Data = AR_CArray.mp_TypeArr ;
|
|
ml_ElePos=(AR_CArray.size()>0 ? 1 : 0 ) ;
|
|
}/*
|
|
ZCNodePoint(ZtCArray& AR_CArray)*/
|
|
|
|
ZCNodePoint(const ZCNodePoint& rhs) : mr_CArray(rhs.mr_CArray)
|
|
{
|
|
mp_Data = rhs.mp_Data ;
|
|
ml_ElePos= (mr_CArray.size()>0 ? 1 : 0 );
|
|
}/*
|
|
ZCNodePoint(const ZCNodePoint& rhs)*/
|
|
|
|
|
|
TypeThis & GetMain() {return mr_CArray ;}
|
|
TypeNode GetNode() {return mp_Data ;}
|
|
|
|
TypeThisC& GetMain() const{return mr_CArray ;}
|
|
TypeNodeC GetNode() const{return mp_Data ;}
|
|
|
|
TypeSize GetPos () const{return ml_ElePos ;}
|
|
TypeSize size () const{return mr_CArray.size();}
|
|
|
|
TypeData & operator* () {return *mp_Data;}
|
|
TypeData * operator->() {return mp_Data;}
|
|
TypeDataC& operator* () const{return *mp_Data;}
|
|
TypeDataC* operator->() const{return mp_Data;}
|
|
|
|
TypeIter & operator++( ) {++mp_Data; ++ml_ElePos; return *this;}
|
|
TypeIter operator++(int) {++mp_Data; ++ml_ElePos; return *this;}
|
|
TypeIter & operator--( ) {--mp_Data; --ml_ElePos; return *this;}
|
|
TypeIter operator--(int) {--mp_Data; --ml_ElePos; return *this;}
|
|
|
|
ZCNodePointC& operator++( ) const{++mp_Data; ++ml_ElePos; return *this;}
|
|
ZCNodePointC operator++(int) const{++mp_Data; ++ml_ElePos; return *this;}
|
|
ZCNodePointC& operator--( ) const{--mp_Data; --ml_ElePos; return *this;}
|
|
ZCNodePointC operator--(int) const{--mp_Data; --ml_ElePos; return *this;}
|
|
|
|
TypeIter operator+(TSize AL_AddPos) const
|
|
{
|
|
return ZCNodePoint(*this, mp_Data+AL_AddPos, ml_ElePos+AL_AddPos);
|
|
}/*
|
|
TypeIter operator+(TSize AL_AddPos) const*/
|
|
|
|
|
|
bool operator == (ZCNodePointC& rhs) const
|
|
{ return ml_ElePos == rhs.ml_ElePos; }
|
|
bool operator != (ZCNodePointC& rhs) const
|
|
{ return ml_ElePos != rhs.ml_ElePos; }
|
|
bool operator > (ZCNodePointC& rhs) const
|
|
{ return ml_ElePos > rhs.ml_ElePos; }
|
|
bool operator >= (ZCNodePointC& rhs) const
|
|
{ return ml_ElePos >= rhs.ml_ElePos; }
|
|
bool operator < (ZCNodePointC& rhs) const
|
|
{ return ml_ElePos < rhs.ml_ElePos; }
|
|
bool operator <= (ZCNodePointC& rhs) const
|
|
{ return ml_ElePos <= rhs.ml_ElePos; }
|
|
|
|
bool operator == (TypeSize AL_Size) const
|
|
{ return ml_ElePos == AL_Size; }
|
|
bool operator != (TypeSize AL_Size) const
|
|
{ return ml_ElePos != AL_Size; }
|
|
bool operator > (TypeSize AL_Size) const
|
|
{ return ml_ElePos > AL_Size; }
|
|
bool operator >= (TypeSize AL_Size) const
|
|
{ return ml_ElePos >= AL_Size; }
|
|
bool operator < (TypeSize AL_Size) const
|
|
{ return ml_ElePos < AL_Size; }
|
|
bool operator <= (TypeSize AL_Size) const
|
|
{ return ml_ElePos <= AL_Size; }
|
|
|
|
public:
|
|
};/*
|
|
class ZCNodePoint*/
|
|
|
|
|
|
class ZCNodePointN
|
|
{
|
|
private:
|
|
mutable TypeData* mp_Data ;
|
|
mutable TypeSize ml_ElePos; // *mp_Data 가 배열에서 차지하는 위치
|
|
const ZtCArray& mr_CArray;
|
|
public:
|
|
|
|
static ZCNodePointN MakeTailPoint(ZtCArray & AR_CArray)
|
|
{
|
|
ZCNodePointN VO_ZCLinkPoint(AR_CArray);
|
|
|
|
if(AR_CArray.size()>0) /****************************/
|
|
{
|
|
VO_ZCLinkPoint.mp_Data = AR_CArray.mp_TypeArr+AR_CArray.size()-1 ;
|
|
VO_ZCLinkPoint.ml_ElePos = AR_CArray.size() ;
|
|
}
|
|
return VO_ZCLinkPoint; /****************************/
|
|
}/*
|
|
static ZCNodePointN MakeTailPoint(ZtCArray & AR_CArray)*/
|
|
static ZCNodePointN MakeTailPoint(TypeIterC& AR_TypeIter)
|
|
{
|
|
ZCNodePointN VO_ZCLinkPoint(AR_TypeIter);
|
|
|
|
const TypeSize VL_ArrSize = AR_TypeIter.mr_CArray.size();
|
|
|
|
if(VL_ArrSize>0) /**********************************/
|
|
{
|
|
VO_ZCLinkPoint.mp_Data = AR_TypeIter.mr_CArray+VL_ArrSize-1 ;
|
|
VO_ZCLinkPoint.ml_ElePos = VL_ArrSize ;
|
|
}
|
|
return VO_ZCLinkPoint; /****************************/
|
|
}/*
|
|
static ZCNodePointN MakeTailPoint(TypeIterC& AR_TypeIter)*/
|
|
static ZCNodePointN MakeTailPoint(TypeIterN& AR_TypeIter)
|
|
{
|
|
ZCNodePointN VO_ZCLinkPoint(AR_TypeIter);
|
|
|
|
const TypeSize VL_ArrSize = AR_TypeIter.mr_CArray.size();
|
|
|
|
if(VL_ArrSize>0) /**********************************/
|
|
{
|
|
VO_ZCLinkPoint.mp_Data = AR_TypeIter.mr_CArray+VL_ArrSize-1 ;
|
|
VO_ZCLinkPoint.ml_ElePos = VL_ArrSize ;
|
|
}
|
|
return VO_ZCLinkPoint; /****************************/
|
|
}/*
|
|
static ZCNodePointN MakeTailPoint(TypeIterN& AR_TypeIter)*/
|
|
|
|
public:
|
|
|
|
ZCNodePointN(const ZtCArray& AR_CArray, Type& AR_CData, TSize AL_ElePos) :
|
|
mr_CArray(AR_CArray)
|
|
/*****************************************************************/
|
|
{
|
|
mp_Data =&AR_CData ;
|
|
ml_ElePos=AL_ElePos ;
|
|
}/*
|
|
ZCNodePointN(ZtCArray& AR_CArray, Type& AR_CData, TSize AL_ElePos)*/
|
|
|
|
ZCNodePointN(ZtCArray& AR_CArray) : mr_CArray(AR_CArray)
|
|
{
|
|
mp_Data = AR_CArray.mp_Data ;
|
|
ml_ElePos=(AR_CArray.size()>0 ? 1 : 0 ) ;
|
|
}/*
|
|
ZCNodePointN(ZtCArray& AR_CArray)*/
|
|
|
|
ZCNodePointN(const ZCNodePointN& rhs) : mr_CArray(rhs.mr_CArray)
|
|
{
|
|
mp_Data = rhs.mp_Data ;
|
|
ml_ElePos=(mr_CArray.size()>0 ? 1 : 0 ) ;
|
|
}/*
|
|
ZCNodePointN(const ZCNodePointN& rhs)*/
|
|
ZCNodePointN(const ZCNodePoint & rhs) : mr_CArray(rhs.mr_CArray)
|
|
{
|
|
mp_Data = rhs.mp_Data ;
|
|
ml_ElePos=(mr_CArray.size()>0 ? 1 : 0 ) ;
|
|
}/*
|
|
ZCNodePointN(const ZCNodePoint & rhs)*/
|
|
|
|
|
|
TypeSize size () const{return mr_CArray.size();}
|
|
TypeSize GetPos() const{return ml_ElePos ;}
|
|
|
|
TypeDataC& operator* () const{return *mp_Data;}
|
|
TypeDataC* operator->() const{return mp_Data;}
|
|
|
|
|
|
TypeIterN& operator++( ) const{++mp_Data; ++ml_ElePos; return *this;}
|
|
TypeIterN operator++(int) const{++mp_Data; ++ml_ElePos; return *this;}
|
|
|
|
TypeIterN operator+(TSize AL_AddPos) const
|
|
{
|
|
return ZCNodePointN(*this, mp_Data+AL_AddPos, ml_ElePos+AL_AddPos);
|
|
}/*
|
|
TypeIterN operator+(TSize AL_AddPos) const*/
|
|
|
|
|
|
bool operator == (const ZCNodePointN& rhs) const
|
|
{ return ml_ElePos == rhs.ml_ElePos; }
|
|
bool operator != (const ZCNodePointN& rhs) const
|
|
{ return ml_ElePos != rhs.ml_ElePos; }
|
|
bool operator > (const ZCNodePointN& rhs) const
|
|
{ return ml_ElePos > rhs.ml_ElePos; }
|
|
bool operator >= (const ZCNodePointN& rhs) const
|
|
{ return ml_ElePos >= rhs.ml_ElePos; }
|
|
bool operator < (const ZCNodePointN& rhs) const
|
|
{ return ml_ElePos < rhs.ml_ElePos; }
|
|
bool operator <= (const ZCNodePointN& rhs) const
|
|
{ return ml_ElePos <= rhs.ml_ElePos; }
|
|
|
|
bool operator == (TypeSize AL_Size) const
|
|
{ return ml_ElePos == AL_Size; }
|
|
bool operator != (TypeSize AL_Size) const
|
|
{ return ml_ElePos != AL_Size; }
|
|
bool operator > (TypeSize AL_Size) const
|
|
{ return ml_ElePos > AL_Size; }
|
|
bool operator >= (TypeSize AL_Size) const
|
|
{ return ml_ElePos >= AL_Size; }
|
|
bool operator < (TypeSize AL_Size) const
|
|
{ return ml_ElePos < AL_Size; }
|
|
bool operator <= (TypeSize AL_Size) const
|
|
{ return ml_ElePos <= AL_Size; }
|
|
|
|
public:
|
|
};/*
|
|
class ZCNodePointN*/
|
|
|
|
|
|
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()*/
|
|
|
|
ZtCArray& operator=(const ZtCArray& rhs)
|
|
{
|
|
if(this==&rhs) return *this ;
|
|
|
|
ReAlloc(rhs.ml_UseSize, false);
|
|
|
|
ml_UseSize = rhs.ml_UseSize;
|
|
ml_AllSize = rhs.ml_AllSize;
|
|
|
|
for(TypeSize i=0; i<ml_UseSize; ++i)
|
|
{
|
|
mp_TypeArr[i] = rhs.mp_TypeArr[i];
|
|
}/*
|
|
for(TypeSize i=0; i<ml_UseSize; ++i)*/
|
|
|
|
return *this;
|
|
}/*
|
|
ZtCArray& operator=(const ZtCArray& rhs)*/
|
|
|
|
ZtCArray& operator()(TypeArg AR_TypeArg)
|
|
{
|
|
AddTail(AR_TypeArg); return *this;
|
|
}/*
|
|
ZtCArray& 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)
|
|
{
|
|
return mp_TypeArr[AL_Index] ;
|
|
}/*
|
|
Type& operator[](TypeSize AL_Index)*/
|
|
|
|
const Type& operator[](TypeSize AL_Index) const
|
|
{
|
|
return mp_TypeArr[AL_Index] ;
|
|
}/*
|
|
const Type& operator[](TypeSize AL_Index) const*/
|
|
|
|
|
|
Type& GetData(TypeSize AL_Index)
|
|
{
|
|
return mp_TypeArr[AL_Index] ;
|
|
}/*
|
|
Type& GetData(TypeSize AL_Index)*/
|
|
|
|
const Type& GetData(TypeSize AL_Index) const
|
|
{
|
|
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] ;
|
|
}
|
|
/*:::::::::::::::::::::::::::::::::::*/
|
|
|
|
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] ;
|
|
}
|
|
/*:::::::::::::::::::::::::::::::::::*/
|
|
|
|
return mp_TypeArr[0] ;
|
|
}/*
|
|
Type& AddHead()*/
|
|
|
|
void AddTail(TypeArg AR_TypeArg)
|
|
{
|
|
ReAlloc((ml_UseSize++)+1); mp_TypeArr[ml_UseSize-1]=AR_TypeArg ;
|
|
}/*
|
|
void AddTail(TypeArg AR_TypeArg)*/
|
|
|
|
Type& AddTail()
|
|
{
|
|
// 끝에 빈 원소를 삽입하고 그 원소를 반환한다.
|
|
|
|
ReAlloc((ml_UseSize++)+1); return mp_TypeArr[ml_UseSize-1];
|
|
}/*
|
|
Type& AddTail()*/
|
|
|
|
operator Type&()
|
|
{
|
|
return AddTail();
|
|
}/*
|
|
operator Type&()*/
|
|
|
|
|
|
void push_front(TypeArg AR_TypeArg){AddHead(AR_TypeArg);}
|
|
void push_back (TypeArg AR_TypeArg){AddTail(AR_TypeArg);}
|
|
|
|
TypeData& push_front(){return AddHead();}
|
|
TypeData& push_back (){return AddTail();}
|
|
|
|
TypeIter begin () {return ZCNodePoint (*this);}
|
|
TypeIterN begin () const{return ZCNodePointN(*this);}
|
|
|
|
iterator end () { return ZCNodePoint ::MakeTailPoint(*this); }
|
|
iteratorN end () const{ return ZCNodePointN::MakeTailPoint(*this); }
|
|
|
|
iteratorN cbegin() const{ return ZCNodePointN(*this); }
|
|
iteratorN cend () const{ return ZCNodePointN::MakeTailPoint(*this); }
|
|
|
|
|
|
template<typename TFunctor> void IterElement(TFunctor AO_Functor)
|
|
{
|
|
Type* VP_TypeArr = mp_TypeArr;
|
|
|
|
__for0(TypeSize, i, ml_UseSize)
|
|
{
|
|
ZNsMain::ZtCTypeData<TFunctor>::
|
|
GetObjRef(AO_Functor)( *VP_TypeArr );
|
|
|
|
++VP_TypeArr; //////////////////
|
|
}/*
|
|
__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)
|
|
{
|
|
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
|
|
)
|
|
/*##############################################################*/
|
|
{
|
|
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
|
|
|
|
///////////////////////////////////////////////////////////////////////////*/
|
|
|
|
TypeData * GetHeadIterEasy () {return mp_TypeArr ;}
|
|
TypeData * GetTailIterEasy () {return mp_TypeArr+ml_UseSize-1 ;}
|
|
IterEasyID GetHeadIterEasyID() {return (IterEasyID) mp_TypeArr ;}
|
|
IterEasyID GetTailIterEasyID() {return (IterEasyID)(mp_TypeArr+ml_UseSize-1);}
|
|
|
|
TypeDataC* GetHeadIterEasy () const{return mp_TypeArr ;}
|
|
TypeDataC* GetTailIterEasy () const{return mp_TypeArr+ml_UseSize-1 ;}
|
|
IterEasyIDc GetHeadIterEasyID() const{return (IterEasyID) mp_TypeArr ;}
|
|
IterEasyIDc GetTailIterEasyID() const{return (IterEasyID)(mp_TypeArr+ml_UseSize-1);}
|
|
|
|
void MoveNextIter(TypeData* & APR_CType ) const{++APR_CType ;}
|
|
void MoveNextIter(iterator & ARR_CIterator) const{++ARR_CIterator;}
|
|
void MoveNextIter(IterEasyID & AI_IterEasyID) const
|
|
{ MoveNextIter((TypeData *&)AI_IterEasyID); }
|
|
void MoveNextIter(TypeDataC* & APR_CType ) const{++APR_CType ;}
|
|
void MoveNextIter(iteratorC & ARR_CIterator) const{++ARR_CIterator;}
|
|
void MoveNextIter(IterEasyIDc& AI_IterEasyID) const
|
|
{ MoveNextIter((TypeDataC*&)AI_IterEasyID); }
|
|
|
|
void MovePrevIter(TypeData* & APR_CType ) const{--APR_CType ;}
|
|
void MovePrevIter(iterator & ARR_CIterator) const{--ARR_CIterator;}
|
|
void MovePrevIter(IterEasyID & AI_IterEasyID) const
|
|
{ MovePrevIter((TypeData *&)AI_IterEasyID); }
|
|
void MovePrevIter(TypeDataC* & APR_CType ) const{--APR_CType ;}
|
|
void MovePrevIter(iteratorC & ARR_CIterator) const{--ARR_CIterator;}
|
|
void MovePrevIter(IterEasyIDc& AI_IterEasyID) const
|
|
{ MovePrevIter((TypeDataC*&)AI_IterEasyID); }
|
|
|
|
|
|
TypeData& GetDataInIter(TypeData * AP_CType ) {return *AP_CType ;}
|
|
TypeData& GetDataInIter(iterator & ARR_CIterator) {return *ARR_CIterator;}
|
|
TypeData& GetDataInIter(IterEasyID AI_IterEasyID)
|
|
{ return *(TypeData *)AI_IterEasyID; }
|
|
|
|
TypeDataC& GetDataInIter(TypeDataC * AP_CType ) const{return *AP_CType;}
|
|
TypeDataC& GetDataInIter(iteratorC & ARR_CIterator) const{return *ARR_CIterator;}
|
|
TypeDataC& GetDataInIter(IterEasyIDc AI_IterEasyID) const
|
|
{ return *(TypeDataC*)AI_IterEasyID; }
|
|
|
|
|
|
TypeData & GetDataInIter(TypeData * AP_Type , TypeSize AI_FarNum)
|
|
{ return *(AP_Type + AI_FarNum) ; }
|
|
TypeData & GetDataInIter(iterator & ARR_CIterator , TypeSize AI_FarNum)
|
|
{ return *(ARR_CIterator+AI_FarNum) ; }
|
|
TypeData & GetDataInIter(IterEasyID ARRI_IterEasyID , TypeSize AI_FarNum)
|
|
{ return GetDataInIter((TypeData*)ARRI_IterEasyID , AI_FarNum); }
|
|
|
|
TypeDataC& GetDataInIter(TypeDataC * AP_Type , TypeSize AI_FarNum) const
|
|
{ return *(AP_Type + AI_FarNum); }
|
|
TypeDataC& GetDataInIter(iterator & ARR_CIterator , TypeSize AI_FarNum) const
|
|
{ return *(ARR_CIterator+AI_FarNum); }
|
|
TypeDataC& GetDataInIter(IterEasyIDc ARRI_IterEasyID , TypeSize AI_FarNum) const
|
|
{ return GetDataInIter((TypeDataC*)ARRI_IterEasyID, AI_FarNum); }
|
|
|
|
|
|
TypeData * ItHEasy() {return mp_TypeArr ;}
|
|
TypeData * ItTEasy() {return mp_TypeArr+ml_UseSize-1 ;}
|
|
IterEasyID ItHID () {return (IterEasyID) mp_TypeArr ;}
|
|
IterEasyID ItTID () {return (IterEasyID)(mp_TypeArr+ml_UseSize-1);}
|
|
|
|
TypeDataC* ItHEasy() const{return mp_TypeArr ;}
|
|
TypeDataC* ItTEasy() const{return mp_TypeArr+ml_UseSize-1 ;}
|
|
IterEasyIDc ItHID () const{return (IterEasyID) mp_TypeArr ;}
|
|
IterEasyIDc ItTID () const{return (IterEasyID)(mp_TypeArr+ml_UseSize-1);}
|
|
|
|
void ItNext(TypeData* & APR_CType ) const{++APR_CType ;}
|
|
void ItNext(iterator & ARR_CIterator) const{++ARR_CIterator;}
|
|
void ItNext(IterEasyID & AI_IterEasyID) const
|
|
{ ItNext((TypeData*&)AI_IterEasyID); }
|
|
void ItNext(TypeDataC* & APR_CType ) const{++APR_CType ;}
|
|
void ItNext(iteratorC & ARR_CIterator) const{++ARR_CIterator;}
|
|
void ItNext(IterEasyIDc& AI_IterEasyID) const
|
|
{ ItNext((TypeDataC*&)AI_IterEasyID); }
|
|
|
|
void ItPrev(TypeData* & APR_CType ) const{--APR_CType ;}
|
|
void ItPrev(iterator & ARR_CIterator) const{--ARR_CIterator;}
|
|
void ItPrev(IterEasyID & AI_IterEasyID) const
|
|
{ ItPrev((TypeData*&)AI_IterEasyID); }
|
|
void ItPrev(TypeDataC* & APR_CType ) const{--APR_CType ;}
|
|
void ItPrev(iteratorC & ARR_CIterator) const{--ARR_CIterator;}
|
|
void ItPrev(IterEasyIDc& AI_IterEasyID) const
|
|
{ ItPrev((TypeDataC*&)AI_IterEasyID); }
|
|
|
|
TypeData & ItD(TypeData * AP_Type ) {return GetDataInIter(AP_Type );}
|
|
TypeData & ItD(iterator & ARR_CIterator ) {return GetDataInIter(ARR_CIterator );}
|
|
TypeData & ItD(IterEasyID & ARRI_IterEasyID ) {return GetDataInIter(ARRI_IterEasyID );}
|
|
TypeData & ItD(TypeData * AP_Type , TypeSize AI_FarNum) {return GetDataInIter(AP_Type , AI_FarNum );}
|
|
TypeData & ItD(iterator & ARR_CIterator , TypeSize AI_FarNum) {return GetDataInIter(ARR_CIterator , AI_FarNum);}
|
|
TypeData & ItD(IterEasyID & ARRI_IterEasyID, TypeSize AI_FarNum) {return GetDataInIter(ARRI_IterEasyID, AI_FarNum);}
|
|
|
|
TypeDataC& ItD(TypeDataC * AP_Type ) const{return GetDataInIter(AP_Type );}
|
|
TypeDataC& ItD(iteratorC & ARR_CIterator ) const{return GetDataInIter(ARR_CIterator );}
|
|
TypeDataC& ItD(IterEasyIDc& ARRI_IterEasyID ) const{return GetDataInIter(ARRI_IterEasyID );}
|
|
TypeDataC& ItD(TypeDataC * AP_Type , TypeSize AI_FarNum) const{return GetDataInIter(AP_Type );}
|
|
TypeDataC& ItD(iteratorC & ARR_CIterator , TypeSize AI_FarNum) const{return GetDataInIter(ARR_CIterator , AI_FarNum);}
|
|
TypeDataC& ItD(IterEasyIDc& 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 ZtCArray //////////////
|
|
|
|
////////////////////////////////////////////////
|
|
|
|
|
|
|
|
/*////////////////////////////////////////////////////////////////////
|
|
|
|
■ 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)
|
|
{
|
|
return mp_TypeArr[AL_Index] ;
|
|
}/*
|
|
Type& operator[](TSize AL_Index)*/
|
|
|
|
const Type& operator[](TSize AL_Index) const
|
|
{
|
|
return mp_TypeArr[AL_Index] ;
|
|
}/*
|
|
const Type& operator[](TSize AL_Index) const*/
|
|
|
|
|
|
Type& GetData(TSize AL_Index)
|
|
{
|
|
return mp_TypeArr[AL_Index] ;
|
|
}/*
|
|
Type& GetData(TSize AL_Index)*/
|
|
|
|
const Type& GetData(TSize AL_Index) const
|
|
{
|
|
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__
|