该数组类,是为了满足和JAVA类似的语法而写的,不过初始化方面,还是不够灵活
#ifndef _MULTIARRAY_
#define _MULTIARRAY_
template <typename IT, typename IT2>
void elemcopy(IT srcbegin, IT srcend, IT2 destbegin)
{
while (srcbegin != srcend)
{
*destbegin = *srcbegin;
++destbegin;
++srcbegin;
}
}
template <int DIMEN>
struct DIM_INFO
{
int dimsize[DIMEN];
DIM_INFO(const DIM_INFO<DIMEN - 1>& e, int size)
{
dimsize[0] = size;
elemcopy(&e.dimsize[0], &e.dimsize[DIMEN - 1], &dimsize[1]);
}
DIM_INFO<DIMEN + 1> operator[] (int size) const
{
return DIM_INFO<DIMEN + 1>(*this, int(size));
}
};
template <>
struct DIM_INFO<0>
{
int dimsize[1];
DIM_INFO<1> operator[] (int size) const
{
return DIM_INFO<1>(*this, int(size));
}
};
typedef DIM_INFO<0> 0DIM;
#ifdef DIM
#undef DIM
#endif
#define DIM (0DIM())
#ifndef NULL
#define NULL (0)
#endif
//
#ifdef INITCOUNTER
#undef INITCOUNTER
#endif
#define INITCOUNTER (1)
//
//
template <typename T>
class _share_array_data_
{
public:
_share_array_data_<T> * Duplicate()
{
if (this != NULL)
{
++_nRef;
}
return this;
}
void Release()
{
if (this != NULL)
{
// assert(_nRef >= INITCOUNTER);
--_nRef;
if (_nRef < INITCOUNTER)
{
delete this;
}
}
}
static _share_array_data_<T>* NewData(int size)
{
return ((0 == size)?NULL:(new _share_array_data_<T>(size)));
}
inline int Size() const {return (NULL == this)?0:_nSize;}
inline const T* begin() const {return (NULL == this)?NULL:_pValue;}
inline const T* end() const {return (NULL == this)?NULL:(_pValue + _nSize);}
inline T* begin() {return (NULL == this)?NULL:_pValue;}
inline T* end() {return (NULL == this)?NULL:(_pValue + _nSize);}
private:
_share_array_data_<T>& operator=(const _share_array_data_<T>&);
_share_array_data_(const _share_array_data_<T>&);
_share_array_data_(int size)
{
_nSize = size; // assert(_nSize != 0);
_pValue = new T[size]; // assert(_pValue != NULL);
_nRef = INITCOUNTER;
}
~_share_array_data_()
{
// assert(_nRef < INITCOUNTER);
// assert(_pValue != NULL);
delete[] _pValue;
}
int _nRef;
int _nSize;
T *_pValue;
};
//
template <typename T>
inline void InitFunc(T*, T*)
{}
template <typename T>
inline void InitFunc(T **pbegin, T **pend)
{
MEMSET(pbegin, 0, (pend - pbegin)*sizeof(T*));
}
inline void InitFunc(int *pbegin, int *pend)
{
MEMSET(pbegin, 0, (pend - pbegin)*sizeof(int));
}
inline void InitFunc(short *pbegin, short *pend)
{
MEMSET(pbegin, 0, (pend - pbegin)*sizeof(short));
}
inline void InitFunc(char *pbegin, char *pend)
{
MEMSET(pbegin, 0, (pend - pbegin)*sizeof(char));
}
inline void InitFunc(signed char *pbegin, signed char *pend)
{
MEMSET(pbegin, 0, (pend - pbegin)*sizeof(signed char));
}
//
// Interface: multi_array
template <typename T, int DIMEN>
class multi_array;
//
template<typename T>
class multi_array<T, 1>
{
public:
typedef DIM_INFO<1> THISDIM;
typedef multi_array<T, 1> THISTYPE;
typedef T ELETYPE;
enum {DIMENTION = 1};
typedef T VALTYPE;
typedef _share_array_data_<VALTYPE> DATATYPE;
~multi_array()
{
_pRef->Release();
_pRef = NULL;
}
multi_array() : _pRef(NULL)
{
}
multi_array(const THISDIM& diminfo) : _pRef(DATATYPE::NewData(diminfo.dimsize[0]))
{
InitFunc((_pRef->begin()), (_pRef->end()));
}
multi_array(const THISTYPE& src) : _pRef(src._pRef->Duplicate())
{
}
multi_array(THISTYPE *psrc) : _pRef(NULL)
{
if (psrc != NULL)
{
_pRef = psrc->_pRef->Duplicate();
delete psrc;
}
}
//
THISTYPE& operator = (const THISDIM& diminfo)
{
_pRef->Release();
_pRef = DATATYPE::NewData(diminfo.dimsize[0]);
InitFunc((_pRef->begin()), (_pRef->end()));
return *this;
}
THISTYPE& operator = (const THISTYPE& src)
{
if (_pRef != src._pRef)
{
_pRef->Release();
_pRef = src._pRef->Duplicate();
}
return *this;
}
THISTYPE& operator = (THISTYPE *psrc) // 只是为了适应JAVA语法[Object a; a = new Object;]
{
if (psrc != NULL)
{
if (_pRef != psrc->_pRef)
{
_pRef->Release();
_pRef = psrc->_pRef->Duplicate();
}
else if (this != psrc)
{
delete psrc;
}
}
else
{
_pRef->Release();
_pRef = NULL;
}
return *this;
}
inline VALTYPE& operator [] (int index)
{
return (_pRef->begin())[index];
}
inline const VALTYPE& operator [] (int index) const
{
return (_pRef->begin())[index];
}
inline int length() const {return _pRef->Size();}
inline VALTYPE *begin() {return (_pRef->begin());}
inline const VALTYPE *begin() const {return (_pRef->begin());}
inline VALTYPE *end() {return (_pRef->end());}
inline const VALTYPE *end() const {return (_pRef->end());}
inline operator boolean() const {return (_pRef != NULL);}
friend inline boolean operator == (const THISTYPE& _l, const THISTYPE& _r)
{
return (_l._pRef == _r._pRef);
}
friend inline boolean operator != (const THISTYPE& _l, const THISTYPE& _r)
{
return (_l._pRef != _r._pRef);
}
private:
DATATYPE *_pRef;
};
//
template <typename T, int DIMEN>
class multi_array
{
public:
typedef DIM_INFO<DIMEN> THISDIM;
typedef DIM_INFO<DIMEN - 1> NEXTDIM;
typedef multi_array<T, DIMEN> THISTYPE;
typedef T ELETYPE;
enum {DIMENTION = DIMEN};
typedef multi_array<T, DIMEN - 1> VALTYPE;
typedef _share_array_data_<VALTYPE> DATATYPE;
~multi_array()
{
_pRef->Release();
_pRef = NULL;
}
multi_array() : _pRef(NULL)
{
}
multi_array(const THISDIM& diminfo) : _pRef(DATATYPE::NewData(diminfo.dimsize[DIMEN - 1]))
{
if (_pRef)
{
VALTYPE *pdata = _pRef->begin();
int size = _pRef->Size();
const NEXTDIM& d_1 = (const NEXTDIM&)diminfo;
for (int i = 0; i < size; ++i) pdata[i] = d_1;
}
}
multi_array(const THISTYPE& src) : _pRef(src._pRef->Duplicate())
{
}
multi_array(THISTYPE *psrc) : _pRef(NULL)
{
if (psrc != NULL)
{
_pRef = psrc->_pRef->Duplicate();
delete psrc;
}
}
//
THISTYPE& operator = (const THISDIM& diminfo)
{
_pRef->Release();
_pRef = DATATYPE::NewData(diminfo.dimsize[DIMEN - 1]);
if (_pRef)
{
VALTYPE *pdata = _pRef->begin();
int size = _pRef->Size();
const NEXTDIM& d_1 = (const NEXTDIM&)diminfo;
for (int i = 0; i < size; ++i) pdata[i] = d_1;
}
return *this;
}
THISTYPE& operator = (const THISTYPE& src)
{
if (_pRef != src._pRef)
{
_pRef->Release();
_pRef = src._pRef->Duplicate();
}
return *this;
}
THISTYPE& operator = (THISTYPE *psrc) // 只是为了适应JAVA语法[Object a; a = new Object;]
{
if (psrc != NULL)
{
if (_pRef != psrc->_pRef)
{
_pRef->Release();
_pRef = psrc->_pRef->Duplicate();
}
else if (this != psrc)
{
delete psrc;
}
}
else
{
_pRef->Release();
_pRef = NULL;
}
return *this;
}
inline VALTYPE& operator [] (int index)
{
return (_pRef->begin())[index];
}
inline const VALTYPE& operator [] (int index) const
{
return (_pRef->begin())[index];
}
inline int length() const {return _pRef->Size();}
inline VALTYPE *begin() {return (_pRef->begin());}
inline const VALTYPE *begin() const {return (_pRef->begin());}
inline VALTYPE *end() {return (_pRef->end());}
inline const VALTYPE *end() const {return (_pRef->end());}
inline operator boolean() const {return (_pRef != NULL);}
friend boolean operator == (const THISTYPE& _l, const THISTYPE& _r)
{
return (_l._pRef == _r._pRef);
}
friend boolean operator != (const THISTYPE& _l, const THISTYPE& _r)
{
return (_l._pRef != _r._pRef);
}
private:
DATATYPE *_pRef;
};
//
#endif