admin/RepoMain
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

commit 2025-10-13 13:31 add __for_iter & __for_iterc ZCppMain/ZMainHead.H

Browse Source
This commit is contained in:
sauron
2025-10-13 13:31:34 +09:00
parent 3629380b37
commit 50019e94cd
2 changed files with 163 additions and 40 deletions
Download Patch File Download Diff File Expand all files Collapse all files

14
ZCppMain/ZMainHead.H
View File

@ -470,8 +470,18 @@ using namespace std;
#define __forD1(i, LoopCount) for(i=1; i<=LoopCount; ++i)
#define __for_iter(IterClass, IterObj, IterVar) \
for(IterClass::iterator IterVar=IterObj.begin(); IterVar<=IterObj.size(); ++IterVar)
#define __for_iter( IterClass, IterObj, IterVar) \
for ( \
IterClass::iterator IterVar=IterObj.begin(); \
IterVar<=IterObj.size(); \
++IterVar \
)
#define __for_iterc(IterClass, IterObj, IterVar) \
for ( \
IterClass::const_iterator IterVar=IterObj.begin(); \
IterVar<=IterObj.size(); \
++IterVar \
)

189
ZCppMain/ZtCArray.H
View File

@ -17,70 +17,65 @@ namespace ZNsMain
class ZtCArray //////////////////////////
{
public:
typedef TType Type ;
typedef TType TypeData;
typedef TTypArg TypeArg ;
typedef TSize TypeSize;
typedef TType Type ;
typedef TType TypeData;
typedef TTypArg TypeArg ;
typedef TSize TypeSize;
public:
class ZCDataPoint;
class ZCDataPoint; class ZCDataPointC;
public:
typedef Type* IterEasy;
typedef ZCDataPoint iterator;
typedef ZCDataPoint TypeIter;
public:
typedef const IterEasy IterEasyC;
typedef const ZCDataPoint iteratorC;
typedef const TypeData TypeDataC;
public:
typedef const ZCDataPoint const_iterator;
/**********************************************/
typedef const TypeData TypeDataC ;
typedef const IterEasy IterEasyC ;
/**********************************************/
typedef ZCDataPointC iteratorC ;
/**********************************************/
typedef ZCDataPoint iterator ;
typedef ZCDataPointC const_iterator;
public:
class ZCDataPoint
{
private: mutable
Type* mp_Data ; mutable
TSize ml_ElePos; // *mp_Data 가 배열에서 차지하는 위치
ZtCArray* mp_CArray;
TypeData* mp_Data ; mutable
TypeSize ml_ElePos; // *mp_Data 가 배열에서 차지하는 위치
ZtCArray& mr_CArray;
public:
ZCDataPoint()
{
mp_Data =0;
mp_CArray=0;
ml_ElePos=0;
}/*
ZCDataPoint()*/
ZCDataPoint(ZtCArray& AR_CArray, Type& AR_CData, TSize AL_ElePos)
ZCDataPoint(ZtCArray& AR_CArray, Type& AR_CData, TSize AL_ElePos) :
mr_CArray(AR_CArray)
/*****************************************************************/
{
mp_Data =&AR_CData ;
mp_CArray=&AR_CArray;
mr_CArray=&AR_CArray;
ml_ElePos=AL_ElePos ;
}/*
ZCDataPoint(ZtCArray& AR_CArray, Type& AR_CData, TSize AL_ElePos)*/
ZCDataPoint(ZtCArray& AR_CArray)
ZCDataPoint(ZtCArray& AR_CArray) : mr_CArray(AR_CArray)
{
mp_Data = AR_CArray.mp_TypeArr ;
mp_CArray=&AR_CArray ;
ml_ElePos=(AR_CArray.size()>0 ? 1 : 0 ) ;
}/*
ZCDataPoint(ZtCArray& AR_CArray)*/
ZCDataPoint(const ZtCArray& AR_CArray)
ZCDataPoint(const ZCDataPoint& rhs) : mr_CArray(rhs.mr_CArray)
{
mp_Data = AR_CArray.mp_TypeArr ;
mp_CArray= const_cast<ZtCArray*>(&AR_CArray);
ml_ElePos= (AR_CArray.size()>0 ? 1 : 0 ) ;
mp_Data = rhs.mp_TypeArr ;
ml_ElePos= (mr_CArray.size()>0 ? 1 : 0 );
}/*
ZCDataPoint(const ZtCArray& AR_CArray)*/
ZCDataPoint(const ZCDataPoint& rhs)*/
Type& operator*( ){return *mp_Data;}
Type* operator->(){return mp_Data;}
TypeSize size () const{return mr_CArray.size();}
TypeSize GetPos() const{return ml_ElePos ;}
const Type& operator* () const{return *mp_Data;}
const Type* operator->() const{return mp_Data;}
TypeData & operator* () {return *mp_Data;}
TypeData * operator->() {return mp_Data;}
TypeDataC& operator* () const{return *mp_Data;}
TypeDataC* operator->() const{return mp_Data;}
ZCDataPoint& operator++( ){++mp_Data; ++ml_ElePos; return *this;}
ZCDataPoint operator++(int){++mp_Data; ++ml_ElePos; return *this;}
@ -94,12 +89,130 @@ namespace ZNsMain
}/*
ZCDataPoint operator+(TSize AL_AddPos) const*/
bool operator == (const ZCDataPoint& rhs) const
{ return ml_ElePos == rhs.ml_ElePos; }
bool operator != (const ZCDataPoint& rhs) const
{ return ml_ElePos != rhs.ml_ElePos; }
bool operator > (const ZCDataPoint& rhs) const
{ return ml_ElePos > rhs.ml_ElePos; }
bool operator >= (const ZCDataPoint& rhs) const
{ return ml_ElePos >= rhs.ml_ElePos; }
bool operator < (const ZCDataPoint& rhs) const
{ return ml_ElePos < rhs.ml_ElePos; }
bool operator <= (const ZCDataPoint& 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 ZCDataPoint
class ZCDataPoint*/
public :*/
class ZCDataPointC
{
private:
mutable TypeData* mp_Data ;
mutable TypeSize ml_ElePos; // *mp_Data 가 배열에서 차지하는 위치
const ZtCArray& mr_CArray;
public:
ZCDataPointC(const ZtCArray& AR_CArray, Type& AR_CData, TSize AL_ElePos) :
mr_CArray(AR_CArray)
/*****************************************************************/
{
mp_Data =&AR_CData ;
mr_CArray=&AR_CArray;
ml_ElePos=AL_ElePos ;
}/*
ZCDataPointC(ZtCArray& AR_CArray, Type& AR_CData, TSize AL_ElePos)*/
ZCDataPointC(ZtCArray& AR_CArray) : mr_CArray(AR_CArray)
{
mp_Data = AR_CArray.mp_TypeArr ;
ml_ElePos=(AR_CArray.size()>0 ? 1 : 0 ) ;
}/*
ZCDataPointC(ZtCArray& AR_CArray)*/
ZCDataPointC(const ZCDataPointC& rhs) : mr_CArray(rhs.mr_CArray)
{
mp_Data = rhs.mp_TypeArr ;
ml_ElePos=(mr_CArray.size()>0 ? 1 : 0 ) ;
}/*
ZCDataPointC(const ZCDataPointC& rhs)*/
ZCDataPointC(const ZCDataPoint & rhs) : mr_CArray(rhs.mr_CArray)
{
mp_Data = rhs.mp_TypeArr ;
ml_ElePos=(mr_CArray.size()>0 ? 1 : 0 ) ;
}/*
ZCDataPointC(const ZCDataPoint & 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;}
ZCDataPointC& operator++( ){++mp_Data; ++ml_ElePos; return *this;}
ZCDataPointC operator++(int){++mp_Data; ++ml_ElePos; return *this;}
const ZCDataPointC& operator++( ) const{++mp_Data; ++ml_ElePos; return *this;}
const ZCDataPointC operator++(int) const{++mp_Data; ++ml_ElePos; return *this;}
ZCDataPointC operator+(TSize AL_AddPos) const
{
return ZCDataPointC(*this, mp_Data+AL_AddPos, ml_ElePos+AL_AddPos);
}/*
ZCDataPointC operator+(TSize AL_AddPos) const*/
bool operator == (const ZCDataPointC& rhs) const
{ return ml_ElePos == rhs.ml_ElePos; }
bool operator != (const ZCDataPointC& rhs) const
{ return ml_ElePos != rhs.ml_ElePos; }
bool operator > (const ZCDataPointC& rhs) const
{ return ml_ElePos > rhs.ml_ElePos; }
bool operator >= (const ZCDataPointC& rhs) const
{ return ml_ElePos >= rhs.ml_ElePos; }
bool operator < (const ZCDataPointC& rhs) const
{ return ml_ElePos < rhs.ml_ElePos; }
bool operator <= (const ZCDataPointC& 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 ZCDataPointC*/
public :
/**************************************************************************/
protected:
enum{ZEAddSize=20};
protected: