一个方便好用的数组类

yzhlinux

to Whanxy

int N; 3 |" S5 s) `6 }, G$ p+ KN=StrToInt(Edit1->Text); * X) g7 U- @8 B8 Aint RESULT[N]; 哈哈,这样的代码很有意思哦. 在c++里没有现成的类似vb的redim那样可以自由定义数组边界的办法,很多人提供了一些数组类以实现你这样的需求,同样微软也提供了这样的模板类 CArray ,你可以去参考这个摸板,不过 CArray 写的不够好只能给单线程的地方使用(后来个跟踪进去才发现是它的问题,没把偶气死)并且不能很好的支持使用 & 引用内部的成员(底层机制的问题),我从新改写了它的底层实现,写了一个摸板类,给你用正好满足你的需求.: #if !defined(CYCArray_INCLUDED) #define CYCArray_INCLUDED ! p2 H% R L; X, w, [$ V#include "afxtempl.h" # J: f: e) Z3 j9 {5 y" \: P: ~% X/** * 动态数组的模板类 (Write By yzhlinux ,you could use it any time any way if you could email me about it yzhlinux@hotmail.com) * 1.支持字符索引 . h; M# L9 q$ M7 h0 d, `* 2.方便的添加删除修改任意一项 " W' a- \8 e" A2 m* 最后更新 2004-8-9 6 q5 _; @% d6 z6 {! B; ]$ Z**1.优化了字符索引的运作方式，使用数组存储 **2.重写了底层数据的存储，将连续性的存储方式改为了非连续, *** 从而很好有效地支持了“引用”,并且让数据的删除增加变的更为快速 ///// * 用法句举例1： $ k: E2 W1 D5 }* d( u. A B* YCArray<int,int> test1 ; * W) ]1 `0 L0 C8 k* test1.Add("Number2",4); * test1.Add("Number1",2); 7 r t& n) b$ r% F/ G1 J* printf("%d %d",test1["Number1"],test1["Number2"]); * 显示： ! W/ h u7 ^, ~" m' O1 v( F* 2 4 ///// * 用法句举例2： ' m" A# P0 x! w/ z/ w7 j* YCArray<CString,CString> test2 ; * test2.Add("string2","hahahaha"); * test2.Add("string1","yes yes yes yes"); * printf("%s %s %s",test2["string1"],test2["string2],test2[0]); * 显示： 5 o( Y6 Z9 m6 h7 j. K* yes yes yes yes hahahaha yes yes yes yes ! R3 R, _8 ?* I' E///// 6 C0 p' z4 I) r) ]! A5 v" x f* 用法句举例3: * YCArray<CString,CString> test3 ; : l9 L9 O/ Z# z' P* w; S* test3.Add("string2","hahahaha"); % f2 C K3 y1 W8 |, n/ ]* test3.Add("string1","yes yes yes yes"); * test3.Add("","no no no"); * test3.AddR("string2","yes yes yes yes"); //AddR方法会去搜索字符索引，如果存在则替换 " w3 d1 Y! {/ U A* printf("%s %s %s",test3["string1"],test3["string2],test3[2]); * 显示： : |2 }" H- h$ V3 s8 ], `9 Q* yes yes yes yes yes yes yes yes no no no **/ ///////////////////////////////////////////////////////////////////////////// // YCArray<TYPE, ARG_TYPE> #include <afxmt.h> 5 }% j7 _1 I. ^ B: p9 t2 S, gtemplate<class TYPE, class ARG_TYPE> class YCArray : public CObject 0 \$ g3 p9 A8 a/ S8 a) ?{ 7 g' |+ J0 E0 h; |/ e//friend YCArray<TYPE, ARG_TYPE>; 3 w, K, C: |6 F8 X& WCCriticalSection YCArray_Add; public: 1 W" C, u* U2 e( f// Attributes int GetSize() const; int GetUpperBound() const; void SetSize(int nNewSize, int nGrowBy = -1);

, U; [1 J; a+ ^% P; L7 N8 n

// Operations 0 H; L0 v4 C! B// Clean up 7 @4 q% E$ D' C7 ^1 k8 Avoid FreeExtra(); - O( `7 v; R/ ]0 K1 ?: Pvoid RemoveAll();

/ n7 Y4 ~. |5 H+ R

// Accessing elements TYPE GetAt(int nIndex) const; void SetAt(int nIndex, ARG_TYPE newElement); ) ~: F/ ~! g+ U. v" |+ X6 |TYPE& ElementAt(int nIndex);

TYPE GetAt(CString cIndex) const; void SetAt(CString cIndex, ARG_TYPE newElement); $ X' C' m1 l4 J& h/ |, a/ ITYPE& ElementAt(CString cIndex);

// Direct Access to the element data (may return NULL) + f4 m- Y- |9 Bconst TYPE** GetData() const; ; [' Q1 S8 v( Z: iTYPE** GetData();

// Potentially growing the array void SetAtGrow(int nIndex, ARG_TYPE newElement); , I2 s/ ?) z1 ?$ G! Nvoid SetAtGrow(CString cIndex, ARG_TYPE newElement); int Add(ARG_TYPE newElement,CString cIndex = ""); int AddR(ARG_TYPE newElement,CString cIndex = "")//如果存在就替换 ' X9 d9 @, ?5 \) U- J- l5 a& z{ 9 o+ w) w0 `5 [1 C1 f1 N int nIndex = GetIndex(cIndex); if(cIndex!=""&&nIndex >-1){ / W6 \; D6 @! _/ l7 l# z6 E( Y operator[](nIndex)=newElement; }else{ 7 ~$ O/ o- C/ y1 ^! U! ]; [- H nIndex = m_nSize; ' _' |( H0 W6 ~: z/ B* `. [ SetAtGrow(nIndex, newElement); SETIndex(cIndex,nIndex); return nIndex; } } int AddM(ARG_TYPE newElement,CString cIndex = "") { static int nIndex ; ' S$ B) f/ w- s: X% d0 `# M YCArray_Add.Lock(); nIndex = m_nSize; 3 R$ F# ?1 g. E Z" h1 J7 \ SetAtGrow(nIndex, newElement); 9 Z4 e8 l% ?0 q {( m YCArray_Add.Unlock(); + L8 z6 \" U$ u N! R! }, ~- n( N SETIndex(cIndex,nIndex); return nIndex; 0 V8 _5 b; w9 f& F: C}; : R% O! I0 _2 p1 Q$ o8 v& M6 [int Append(const YCArray& src); void Copy(const YCArray& src);

// overloaded operator helpers TYPE operator[](int nIndex) const; ( c7 h N* \9 T! A1 kTYPE& operator[](int nIndex); * ^: q* q) C: X* c4 V0 U8 _; @TYPE operator[](CString cIndex) const; TYPE& operator[](CString cIndex); . x6 _* N; W2 h8 h; D z//YCArray<TYPE,ARG_TYPE> operator=(YCArray<TYPE,ARG_TYPE>& tparr)const; S' k6 u1 ?. yYCArray<TYPE,ARG_TYPE>& operator=(YCArray<TYPE,ARG_TYPE>& tparr); * V/ I. U9 b3 N: V% q; J// Operations that move elements around 8 j: t' f( r) E" C" h8 Svoid InsertAt(int nIndex, ARG_TYPE newElement, int nCount = 1); 6 n, o& l; K# n; a% j3 svoid RemoveAt(int nIndex, int nCount = 1); void RemoveAt(CString cIndex,int nCount = 1); void InsertAt(int nStartIndex, YCArray* pNewArray); void InsertAt(ARG_TYPE newElement,int nIndex,CString cIndex);

& s s+ l) H' m

int GetIndex(CString cIndex); CString GetIndex(int nIndex);

CString GetSign(); int SetSign(CString& sign);

// Implementation 1 a) Q2 Z$ K* S$ q" }2 s- lprotected: , B8 x. y! s& y- F, ~. pTYPE** Ym_pData; // the actual array of data 9 Q, p* M" ^. t; t/ C _+ @) m" T/ xint m_nSize; // # of elements (upperBound - 1) int m_nMaxSize; // max allocated int m_nGrowBy; // grow amount ( x& Z' E! W, Jprivate: int lock_sign; : ~1 O K, r3 oCString Sign; int MAXSIGNTIME;

CString* strIndex; 1 M' u* m7 r) ?8 Tint strIndexNum; BOOL SetIndexSize(int nIndex); BOOL SETIndex(CString cIndex,int nIndex); BOOL INSERTIndex(int nIndex,int nCount =1); BOOL DELIndex(int nIndex,int nCount = 1); BOOL DELIndex(CString cIndex,int nCount = 1); , ]+ n- l9 ?, F# Z5 w& i/ p+ bvoid DestructAllElement(int nIndex,int nCount) {//销毁对象，包括每个指针指向的对象 DELIndex(nIndex,nCount); ) C8 Y5 x! f W2 u4 E ASSERT(nIndex >= 0); ASSERT(nCount >= 0); ASSERT(nIndex + nCount <= m_nSize); if(nCount>0&&m_nSize>0){ 7 Q. ^; I& X2 w& ^ for(int i =nIndex;i<nIndex+nCount;i++){ & V3 k. T. H/ E //Ym_pData->~TYPE(); // 由于ConstructAllElements 中是 Ym_pData[nIndex] = new TYPE;所以不需要Ym_pData->~TYPE() delete Ym_pData; } * d/ P; t; ~% Q6 x. e } }; void ConstructAllElements(int nIndex,int nCount) % \! j- L% {+ V' ^: D1 O! n r{//创建对象，包括 new 出每个指针指向的对象 $ k/ D% B( s) w0 L1 Y3 O //nIndex = 0; memset((void*)(Ym_pData+nIndex), 0, nCount * sizeof(TYPE*)); ; l1 d2 l/ L( ]; P1 f# f+ ]% T7 B for (; nCount--; nIndex++) Ym_pData[nIndex] = new TYPE; }; ! U) i! Y/ b, d5 ]/ Ypublic: // Construction 8 D9 Q' J; r% _, @4 ]/ }* l8 k. GYCArray(); YCArray(YCArray<TYPE, ARG_TYPE>& tp); - i; {4 o. z4 o5 A* L. t~YCArray(); void Serialize(CArchive&); #ifdef _DEBUG void Dump(CDumpContext&) const; void AssertValid() const; 3 s3 r" C% p$ s4 ]; @: e#endif

% o9 Y: E% u' [' a3 [# c2 \5 x

};

[此贴子已经被作者于2005-1-10 14:04:39编辑过]

yzhlinux

//接上面

template<class TYPE, class ARG_TYPE> YCArray<TYPE, ARG_TYPE>::~YCArray() { 5 m, `0 ]: _5 E ASSERT_VALID(this);

if (Ym_pData != NULL) { DestructAllElement(0,m_nSize); //DestructElements<TYPE>(Ym_pData, m_nSize); delete[] (BYTE*)Ym_pData; 6 b* f# @9 `+ h7 _) `+ b/ e } m) Y2 b7 i q" H} 1 J" [, U2 P9 u1 a; z4 Ptemplate<class TYPE, class ARG_TYPE> ( G; I5 D' u5 F/ H. E! B. `: WCString YCArray<TYPE, ARG_TYPE>::GetSign() { 4 s0 z$ \* n `3 C0 \$ ^6 z$ v lock_sign=0; return Sign; # [# ]% c* H: \3 k& I% {} 9 J/ @, f' J$ L- ~$ p, ntemplate<class TYPE, class ARG_TYPE> 1 y' C; O( E7 |2 K1 jint YCArray<TYPE, ARG_TYPE>::SetSign(CString& sign) + }7 \% P6 x2 o. b{ 2 R) u- [# o5 D: S$ \ int i=0; + \ A* r6 U( c; x0 t while(lock_sign&&i<MAXSIGNTIME){ ! @" `: S- v2 h2 ]6 k2 M Sleep(1); 0 j4 I$ t: _0 x" s/ @5 h9 I! P i++; } lock_sign=1; Sign=sign; W$ D _( E, \ return TRUE; } $ x, c+ m% B( q+ B& {//用与把 nindex 后的索引往后推 nCount ,自动调整好buffer ! d4 a& G0 E; d5 _8 Y3 Ftemplate<class TYPE, class ARG_TYPE> 8 R, G4 V1 G# z g& P, DBOOL YCArray<TYPE, ARG_TYPE>::SetIndexSize(int nNewSize) { if(strIndexNum < nNewSize){ CString* tp = new CString[nNewSize];//新的buffer % R+ O9 A' s5 W' F0 a4 @6 H" A for(int i=0;i<strIndexNum;i++){//把老索引复制过来 tp = strIndex; $ b& e, J3 `+ `" V" s1 z } ! C; c, o1 s: S: D$ D for(i=strIndexNum;i<nNewSize;i++){ $ B0 l7 X4 {, E8 k tp = "" ; } " r- P/ g6 y d1 x9 _ delete[] strIndex ; $ }) w& d: Q: Q1 m# A! K3 o strIndex = tp ; strIndexNum = nNewSize ; 2 D9 }5 p3 z& h* C: }1 N% f }else if(strIndexNum < nNewSize){ for(int i=nNewSize;i<strIndexNum;i++){ ) ]( p/ S) f# x5 ^' E strIndex = "" ; } } h+ Y. U7 C. W0 F' f* j- h return TRUE; } template<class TYPE, class ARG_TYPE> " K) f7 V2 q+ W* YBOOL YCArray<TYPE, ARG_TYPE>::INSERTIndex(int nIndex,int nCount /*=1*/) { CString* tp = new CString[m_nSize+nCount];//新的buffer for(int i=0;i<nIndex;i++){//把老索引复制过来 # o1 J I R( C w6 f8 L7 Y, w/ s tp = strIndex; / B* {. W r5 g }int j =0 ; # ^) `5 s# u! _ for(i=nIndex+nCount;i<m_nSize;i++){//把老索引复制过来 , L6 N5 q! I& r2 v5 L3 G tp = strIndex[nIndex+j]; ; D; K: o* {/ L7 v! N& C: t$ h7 v j++; } delete[] strIndex ; strIndex = tp ; / E. @# D; [2 k return TRUE; } template<class TYPE, class ARG_TYPE> 2 k2 E+ J) Y# ~8 R# I, }& g5 g, D$ BBOOL YCArray<TYPE, ARG_TYPE>::SETIndex(CString cIndex,int nIndex) {//在 nIndex 后面添加一个 字符串索引 / N t9 V& u3 u" @! d6 V strIndex[nIndex] = cIndex ; & ~* _2 z) V- t3 r! J! S# v return TRUE; } template<class TYPE, class ARG_TYPE> BOOL YCArray<TYPE, ARG_TYPE>:ELIndex(int nIndex,int nCount /*=1*/) {//需要在 m_nSize 变化之前调用!! 5 J( S$ y8 I( p ASSERT(nIndex >= 0); ; b5 z8 l3 O" w6 g Z. d6 n1 l ASSERT(nCount >= 0); . R) Y4 z- F: M% I ASSERT(nIndex + nCount <= m_nSize); 7 ^% O; D; O3 z* l int j =0 ; for(int i=nIndex+nCount;i<m_nSize;i++){//把老索引复制过来 strIndex[nIndex+j] = strIndex; # b$ @' k, J5 A* b0 f j++; + p4 u; J3 f( L, y, C } return TRUE; } . j& k- L4 S# z% K3 a) R" ?template<class TYPE, class ARG_TYPE> BOOL YCArray<TYPE, ARG_TYPE>:ELIndex(CString cIndex,int nCount /*=1*/) { 3 n9 l( X0 q# ^+ V6 v; j int nIndex=this->GetIndex(cIndex); 3 C: _: a4 b/ r6 [3 `9 Y return this->DELIndex(nIndex,nCount); } 2 F( q X5 L$ P. h, \1 s; wtemplate<class TYPE, class ARG_TYPE> int YCArray<TYPE, ARG_TYPE>::GetIndex(CString cIndex) 1 J9 A' W. } h$ k+ N9 y' N{//得到 cIndex 的数字索引 - w2 c$ k* B* l } c+ i8 ^% i. f& t int nPos = -1; for(int i=0;i<m_nSize;i++){ 1 N5 v/ w' ^3 Q$ b9 e: ` if(strIndex == cIndex){ 8 k- N9 t1 s! l* L9 O5 c+ v3 [ nPos = i ;break; } ) c& h+ R( T, A' V' E } return nPos; } template<class TYPE, class ARG_TYPE> CString YCArray<TYPE, ARG_TYPE>::GetIndex(int nIndex) ; O2 _+ z. D! W$ E) f$ }{//返回 nIndex 的字符串索引 return strIndex[nIndex]; } 3 f6 e+ [5 z5 }! F///////////////////////////////////////////////////////////////////////////// 4 b* n7 c3 e8 `* g$ B4 S// YCArray<TYPE, ARG_TYPE> inline functions

template<class TYPE, class ARG_TYPE> AFX_INLINE int YCArray<TYPE, ARG_TYPE>::GetSize() const { return m_nSize; } template<class TYPE, class ARG_TYPE> 5 v s3 T. x+ `! u4 xAFX_INLINE int YCArray<TYPE, ARG_TYPE>::GetUpperBound() const + A- w- y5 {5 _$ J9 i' }/ y { return m_nSize-1; } / y% b( k/ u; x9 R- stemplate<class TYPE, class ARG_TYPE> ! \$ @( d$ h: I/ a0 V6 ~# l1 GAFX_INLINE void YCArray<TYPE, ARG_TYPE>::RemoveAll() Q% ?& B3 W1 o4 P& E$ z8 y& g( k { SetSize(0, -1); } . }/ |, E8 \0 Wtemplate<class TYPE, class ARG_TYPE> " \( A* M2 [, b1 d( @$ @- c! [5 h! xAFX_INLINE TYPE YCArray<TYPE, ARG_TYPE>::GetAt(int nIndex) const $ I. n1 D; ], I+ M& y# ~ { ASSERT(nIndex >= 0 && nIndex < m_nSize); 3 S7 p8 k# j( b2 b4 E# C return *Ym_pData[nIndex]; } & M& V Y' L2 I3 w- g itemplate<class TYPE, class ARG_TYPE> 7 u+ G4 M* ]" a0 ]1 S$ [9 NAFX_INLINE void YCArray<TYPE, ARG_TYPE>::SetAt(int nIndex, ARG_TYPE newElement) 2 Y, d. v" ^3 p) H. n7 p7 } { ASSERT(nIndex >= 0 && nIndex < m_nSize); *(Ym_pData[nIndex]) = newElement; }

template<class TYPE, class ARG_TYPE> AFX_INLINE TYPE& YCArray<TYPE, ARG_TYPE>::ElementAt(int nIndex) / T$ L2 D' O# k9 q" q { ASSERT(nIndex >= 0 && nIndex < m_nSize); 6 R3 n2 x' y7 T+ ~5 m return *Ym_pData[nIndex]; }

template<class TYPE, class ARG_TYPE> TYPE YCArray<TYPE, ARG_TYPE>::GetAt(CString cIndex) const ! o0 A. m0 ], L2 u8 A{ int nIndex=GetIndex(cIndex); ) |$ b: R" M: H, @9 x; y8 N, H$ ^ return GetAt(nIndex); " q% g) H* p5 k* I1 U} template<class TYPE, class ARG_TYPE> ) \, k" a4 Z( D( [7 C* ivoid YCArray<TYPE, ARG_TYPE>::SetAt(CString cIndex, ARG_TYPE newElement) { int nIndex=GetIndex(cIndex); 3 k0 m {. }# n2 b4 [* H8 e return SetAt(nIndex, newElement); } template<class TYPE, class ARG_TYPE> 7 {1 V: R6 s5 V! \- dTYPE& YCArray<TYPE, ARG_TYPE>::ElementAt(CString cIndex) { , R1 K$ M A1 x' i2 ]6 y/ q9 B int nIndex=GetIndex(cIndex); return ElementAt(nIndex); } $ B* \" F1 K3 }' `! D$ V' u6 P3 Otemplate<class TYPE, class ARG_TYPE> [, \6 O4 V2 [3 O' NAFX_INLINE const TYPE** YCArray<TYPE, ARG_TYPE>::GetData() const ; ^0 G. B* [# w# Z { return (const TYPE**)Ym_pData; } template<class TYPE, class ARG_TYPE> AFX_INLINE TYPE** YCArray<TYPE, ARG_TYPE>::GetData() { return (TYPE**)Ym_pData; } template<class TYPE, class ARG_TYPE> 4 z% `+ `4 U+ {8 G( W# |6 w: w$ A7 rAFX_INLINE int YCArray<TYPE, ARG_TYPE>::Add(ARG_TYPE newElement,CString cIndex /* ="" */) { int nIndex = m_nSize; SetAtGrow(nIndex, newElement); 1 G( Q. s! o; V) t- I: t3 ?3 j$ ^6 G SETIndex(cIndex,nIndex); 8 I; I$ t5 c* u2 j return nIndex; } template<class TYPE, class ARG_TYPE> AFX_INLINE TYPE YCArray<TYPE, ARG_TYPE>:perator[](int nIndex) const { return GetAt(nIndex); } template<class TYPE, class ARG_TYPE> AFX_INLINE TYPE& YCArray<TYPE, ARG_TYPE>:perator[](int nIndex) { return ElementAt(nIndex); } template<class TYPE, class ARG_TYPE> # a: `. g# g; Z; @7 e7 v8 yAFX_INLINE TYPE YCArray<TYPE, ARG_TYPE>:perator[](CString cIndex) const . d" A9 d# [" W8 o$ e* o0 M{ + n4 D0 a+ \7 x& L0 I int nIndex=GetIndex(cIndex);

return operator[](nIndex); } 5 i4 u* O* G3 {/ P3 B4 H, U9 q# ^template<class TYPE, class ARG_TYPE> * S0 ?- [& w& NAFX_INLINE TYPE& YCArray<TYPE, ARG_TYPE>:perator[](CString cIndex) ) D z/ j8 c5 S' T{ ) z' e. J" }/ q$ K. q- C int nIndex=GetIndex(cIndex); return operator[](nIndex); ' w- o8 ?2 Z& }- ]' k. X" C} ; @, e9 a) R, o/* template<class TYPE, class ARG_TYPE> AFX_INLINE YCArray<TYPE,ARG_TYPE> YCArray<TYPE, ARG_TYPE>:perator=(YCArray<TYPE,ARG_TYPE>& tparr) const { 5 s9 v5 Z0 O- [3 ?0 W! _ int i,j; for(i=0;i<tparr.GetSize();i++){ j = GetIndex(tparr.GetIndex(i)); / M/ Q: s! R/ ]" C if(j>-1){ 7 }- e8 ^( |/ f! u& D- F! \ operator[](tparr.GetIndex(i)) = tparr; }else{ Add(tparr,tparr.GetIndex(i)); } } . d' G* A$ l0 J+ z$ E return this; } 8 A( }% v2 `4 j, f*/ template<class TYPE, class ARG_TYPE> 5 p4 A) M% }' Q, _) O) t8 PAFX_INLINE YCArray<TYPE,ARG_TYPE>& YCArray<TYPE, ARG_TYPE>:perator=(YCArray<TYPE,ARG_TYPE>& src) ) K+ q% h1 M# p( L! X+ B4 }# J, L; \2 C{ , S c5 u ]9 q; R( `! J ASSERT_VALID(this); ASSERT(this != &src); // cannot append to itself

SetSize(src.m_nSize); ; y% k' @* k( o* d6 k" L: q for(int i=0;i<m_nSize;i++){ /*将此句修改为内存拷贝*/// " ]/ f, K% o9 t9 o6 w- p% F *Ym_pData = *src.Ym_pData ; //memcpy(Ym_pData,src.Ym_pData,sizeof(TYPE)); 7 G, a k0 j: R' x SETIndex(src.GetIndex(i),i); } return *this; } ///////////////////////////////////////////////////////////////////////////// # R' S: E1 V! w2 |4 a* p& y9 @// YCArray<TYPE, ARG_TYPE> out-of-line functions

template<class TYPE, class ARG_TYPE> p' h+ e0 w6 EYCArray<TYPE, ARG_TYPE>::YCArray() ! J) }8 Y \! e{ Ym_pData = NULL; strIndexNum = m_nSize = m_nMaxSize = m_nGrowBy = 0; strIndex=NULL;MAXSIGNTIME=10; } template<class TYPE, class ARG_TYPE> " } ]$ x8 A7 n9 m' _YCArray<TYPE, ARG_TYPE>::YCArray(YCArray<TYPE, ARG_TYPE>& tp) { Ym_pData = NULL; strIndexNum = m_nSize = m_nMaxSize = m_nGrowBy = 0; strIndex=NULL;MAXSIGNTIME=10; & O* q2 g7 j; j* h0 r operator=(tp); }

template<class TYPE, class ARG_TYPE> # {5 R+ Q1 y' i; [: qvoid YCArray<TYPE, ARG_TYPE>::SetSize(int nNewSize, int nGrowBy) & f4 W; i" v/ s" G5 k* w{ , ^1 Z6 K' g& T0 L, v8 W ASSERT_VALID(this); ASSERT(nNewSize >= 0);

if (nGrowBy != -1) ) ~$ V' I, J# l2 j3 Q7 w; Q2 X, ] m_nGrowBy = nGrowBy; // set new size

if (nNewSize == 0){ S, n: B- e% j2 X R+ d7 C0 O& j // shrink to nothing ; ~, z: T) h, [6 r" F/ n( d if (Ym_pData != NULL){ - l* Y+ I; c5 k- o' K" b& l DestructAllElement(0,m_nSize); 2 f. r5 F v2 C/ q8 P" [1 j6 T4 ]( _ //DestructElements<TYPE>(Ym_pData, m_nSize); # Y/ a- E# ?, x* y& x delete[] (BYTE*)Ym_pData; 1 |( k/ l0 v. @3 L& H3 I7 p* X5 h Ym_pData = NULL; , x4 f: m1 E2 @& ~% t' g6 K8 s7 P } m_nSize = m_nMaxSize = 0; } else if (Ym_pData == NULL){ # I" K- E) B1 f h- b$ S! h1 t6 m // create one with exact size #ifdef SIZE_T_MAX 5 Y! U3 T6 a1 ]0 n- j+ @/ g ASSERT(nNewSize <= SIZE_T_MAX/sizeof(TYPE*)); // no overflow #endif % i ]- w7 N" Z3 i Ym_pData = (TYPE**) new BYTE[nNewSize * sizeof(TYPE*)]; ; l# K! _ w8 R ConstructAllElements(0,nNewSize);//ConstructElements<TYPE>(Ym_pData, nNewSize); m_nSize = m_nMaxSize = nNewSize; } else if (nNewSize <= m_nMaxSize){ , {& K$ \* n, l3 P( `/ L7 U2 y/ L* g3 u // it fits 3 [# M8 Y0 C& o" N' h if (nNewSize > m_nSize) { ; P: q: z. V( L- _ // initialize the new elements ( C' V) d2 d2 {, i2 _! V ConstructAllElements(m_nSize,nNewSize-m_nSize);//ConstructElements<TYPE>(&Ym_pData[m_nSize], nNewSize-m_nSize); # Z" P# x- X7 j, p4 c9 a } ' I( T+ |6 m" x9 q else if (m_nSize > nNewSize) { 1 m4 S5 S, ^2 f# s$ |) l& B" M // destroy the old elements & A4 _5 P( S1 O- d DestructAllElement(nNewSize,m_nSize-nNewSize); //DestructElements<TYPE>(&Ym_pData[nNewSize], m_nSize-nNewSize); . {* o( Y* j( A& {# g6 h } m_nSize = nNewSize; } else { // otherwise, grow array " P4 i m/ _) h( C0 d5 T0 v int nGrowBy = m_nGrowBy; if (nGrowBy == 0) 6 u# a; P: `" U; K { // heuristically determine growth when nGrowBy == 0 8 s& P, b5 O) j. u2 N, l& @! _' n // (this avoids heap fragmentation in many situations) , x2 \( X7 w" k; x7 I nGrowBy = m_nSize / 8; 4 ~2 Q# R' v4 u' q2 m% U6 i nGrowBy = (nGrowBy < 4) ? 4 : ((nGrowBy > 1024) ? 1024 : nGrowBy); ) |" `5 p/ r/ R1 Z) X } int nNewMax; 3 F& D6 L: D9 t+ |. y; ] if (nNewSize < m_nMaxSize + nGrowBy) nNewMax = m_nMaxSize + nGrowBy; // granularity else nNewMax = nNewSize; // no slush

ASSERT(nNewMax >= m_nMaxSize); // no wrap around 3 q& o# l( h3 e2 T#ifdef SIZE_T_MAX . A- a$ |7 V8 z" N. Z1 `. s: P8 ` ASSERT(nNewMax <= SIZE_T_MAX/sizeof(TYPE)); // no overflow #endif ) a3 b3 |$ |3 O$ p! | TYPE** pNewData = (TYPE**) new BYTE[nNewMax * sizeof(TYPE*)];//TYPE* pNewData = (TYPE*) new BYTE[nNewMax * sizeof(TYPE)];

// copy new data from old - z+ J* a G+ A7 L& L7 W/ ?$ H memcpy(pNewData, Ym_pData, m_nSize * sizeof(TYPE*));

// construct remaining elements ASSERT(nNewSize > m_nSize); //throw("/*wait for me --- yzhlinux*/"); 8 s" ^$ ^) H3 U! ~+ z- v delete[] (BYTE*)Ym_pData; Ym_pData = pNewData; ConstructAllElements(m_nSize,nNewSize-m_nSize);//ConstructElements<TYPE>(&pNewData[m_nSize], nNewSize-m_nSize);

// get rid of old stuff (note: no destructors called) 6 L8 X( ]$ z/ ~ m_nSize = nNewSize; / o8 d% G7 y& B) ^/ u, \+ V& x9 ` m_nMaxSize = nNewMax; # ?6 ?* K: N0 W$ d1 K& V } 7 v4 g3 ]( Z- m. X- o' n SetIndexSize(nNewSize); }

yzhlinux

//接上面

template<class TYPE, class ARG_TYPE> : t( ` d( u" Q$ M. Tint YCArray<TYPE, ARG_TYPE>::Append(const YCArray& src) { ASSERT_VALID(this); ASSERT(this != &src); // cannot append to itself

int nOldSize = m_nSize; SetSize(m_nSize + src.m_nSize);

ConstructAllElements(nOldSize,src.m_nSize); for(int i=nOldSize;i<m_nSize;i++){ /*将此句修改为内存拷贝*/// *Ym_pData = *src.Ym_pData[i-nOldSize] ; //memcpy(Ym_pData,src.Ym_pData[i-nOldSize],sizeof(TYPE)); SETIndex(src.GetIndex(i-nOldSize),i); } / o6 V% j5 P9 C/ {) m# O /*wait for me*///CopyElements<TYPE>(Ym_pData + nOldSize, src.Ym_pData, src.m_nSize); return nOldSize; }

template<class TYPE, class ARG_TYPE> void YCArray<TYPE, ARG_TYPE>::Copy(const YCArray& src) 9 K' L( r( R, q; L+ U, u9 f: N{ ASSERT_VALID(this); ASSERT(this != &src); // cannot append to itself

SetSize(src.m_nSize); for(int i=0;i<m_nSize;i++){ /*将此句修改为内存拷贝*///*Ym_pData = *src.Ym_pData ; memcpy(Ym_pData,src.Ym_pData,sizeof(TYPE)); SETIndex(src.GetIndex(i),i); } 0 Y5 t6 M! ~9 {$ @6 d5 N6 G /*wait for me*///CopyElements<TYPE>(Ym_pData, src.Ym_pData, src.m_nSize); }

template<class TYPE, class ARG_TYPE> void YCArray<TYPE, ARG_TYPE>::FreeExtra() { ASSERT_VALID(this);

if (m_nSize != m_nMaxSize) { // shrink to desired size #ifdef SIZE_T_MAX 6 L, I8 b: Y' g% \ ASSERT(m_nSize <= SIZE_T_MAX/sizeof(TYPE)); // no overflow #endif 6 ?, y) |$ n! Y# k! F TYPE* pNewData = NULL; . S7 b" L3 P1 w) `! K) S if (m_nSize != 0) * M3 `- y- b) ^5 V { pNewData = (TYPE**) new BYTE[m_nSize * sizeof(TYPE*)]; # w# W' S, b, N* f; Q5 e" n! h$ n. t$ O% x' _ // copy new data from old memcpy(pNewData, Ym_pData, m_nSize * sizeof(TYPE*)); }

// get rid of old stuff (note: no destructors called) delete[] (BYTE*)Ym_pData; % B& W, t. b, l- ~ Ym_pData = pNewData; 4 d) Q& x3 G: i$ a7 J* P( \2 C m_nMaxSize = m_nSize; 1 E7 }8 {5 ]- [" O! Y6 s } } template<class TYPE, class ARG_TYPE> # _6 q: ]9 Z; E# R, j; ]' q) s$ {void YCArray<TYPE, ARG_TYPE>::SetAtGrow(CString cIndex, ARG_TYPE newElement) 8 D1 O+ z$ A6 s4 T0 F$ M3 d{ $ C _ F1 l t# `$ J2 R% R int nIndex=GetIndex(cIndex); # \: j) u1 I7 Y# R. m7 M return SetAtGrow(nIndex,newElement); + Z. F8 G8 u- ?" i" \+ J} ' Q1 T% d; M; O, l2 Stemplate<class TYPE, class ARG_TYPE> void YCArray<TYPE, ARG_TYPE>::SetAtGrow(int nIndex, ARG_TYPE newElement) { ASSERT_VALID(this); ) W/ l( _8 ^1 `) X- B0 [ ASSERT(nIndex >= 0);

if (nIndex >= m_nSize) SetSize(nIndex+1, -1); / \& e( p! }) L1 {% C7 i *Ym_pData[nIndex] = newElement; ! d G3 P1 @; P! p}

template<class TYPE, class ARG_TYPE> $ w9 l* L6 O4 Bvoid YCArray<TYPE, ARG_TYPE>::InsertAt(int nIndex, ARG_TYPE newElement, int nCount /*=1*/) ' [" L j' g( D% u* `{ 3 |$ J T5 d, Y0 f ASSERT_VALID(this); 4 ?3 i. G& V: j% x, B# E# Y ASSERT(nIndex >= 0); // will expand to meet need ASSERT(nCount > 0); // zero or negative size not allowed

if (nIndex >= m_nSize) { // adding after the end of the array / B+ ^% q: I4 I2 o SetSize(nIndex + nCount, -1); // grow so nIndex is valid 6 o5 Z# T6 P; D& |2 N } * b8 a t' Q9 }* E else { // inserting in the middle of the array * l% f( R% z! x int nOldSize = m_nSize; ( C. K8 _, T0 a6 {& F$ ] SetSize(m_nSize + nCount, -1); // grow it to new size // destroy intial data before copying over it 2 e. {) `$ y8 ~ /*不需要销毁了,因为 SetSize 的是指针*///DestructAllElement(nOldSize,nCount); ; \' }; [) a: Z, ]& t( Z //DestructElements<TYPE>(&Ym_pData[nOldSize], nCount); 0 X2 e0 O' ~6 X- { // shift old data up to fill gap memmove(&Ym_pData[nIndex+nCount], &Ym_pData[nIndex], (nOldSize-nIndex) * sizeof(TYPE*));

// re-init slots we copied from /*不需要销毁了,因为 SetSize 的是指针*///ConstructAllElements(nIndex,nCount);//ConstructElements<TYPE>(&Ym_pData[nIndex], nCount); }

// insert new value in the gap ASSERT(nIndex + nCount <= m_nSize); ) @% x* X/ u/ s* N( z' A while (nCount--){ *Ym_pData[nIndex++] = newElement; } % J2 [3 o' M- n- i} + l' o* {1 }7 I2 Q- Ptemplate<class TYPE, class ARG_TYPE> 5 h- G4 V* o/ n5 l, W# f( ]; e9 P+ F6 wvoid YCArray<TYPE, ARG_TYPE>::RemoveAt(CString cIndex,int nCount /*=1*/) 4 T' n" C4 p. G; l0 L4 Q+ |6 Q# G{ ! |4 S2 Q2 Q' h- a" U6 j0 D int nIndex = GetIndex(cIndex); $ e. |$ ^0 C, o' O3 z RemoveAt(nIndex,nCount); E, r/ q$ d3 p7 e" d: D} ! P) a0 \% \3 y3 B# rtemplate<class TYPE, class ARG_TYPE> - I; r$ |9 `6 {* q3 Nvoid YCArray<TYPE, ARG_TYPE>::RemoveAt(int nIndex, int nCount /*=1*//*=1*/) { ASSERT_VALID(this); ASSERT(nIndex >= 0); $ o9 K- W; R' T. |6 ?* {' i ASSERT(nCount >= 0); ASSERT(nIndex + nCount <= m_nSize); //yzh DELIndex(nIndex); //yzh * t) [. D" v1 d- d. L1 V // just remove a range int nMoveCount = m_nSize - (nIndex + nCount); //需要移动的数目 DestructAllElement(nIndex,nCount); //DestructElements<TYPE>(&Ym_pData[nIndex], nCount); if (nMoveCount) . e$ u: ~# Q) ~0 Z" V memmove(&Ym_pData[nIndex], &Ym_pData[nIndex + nCount], : [" f: t' b1 X$ E nMoveCount * sizeof(TYPE*)); % D6 O& C/ x& U z9 x; g m_nSize -= nCount; }

template<class TYPE, class ARG_TYPE> void YCArray<TYPE, ARG_TYPE>::InsertAt(int nStartIndex, YCArray* pNewArray) { ASSERT_VALID(this); ASSERT(pNewArray != NULL); ASSERT_VALID(pNewArray); ASSERT(nStartIndex >= 0);

if (pNewArray->GetSize() > 0) ) U" J$ T: Z! K- Z: N, h: m, i* E { 5 I2 U8 o* U6 Q0 { InsertAt(nStartIndex, pNewArray->GetAt(0), pNewArray->GetSize()); 5 Y( s$ I# w: J9 Y, M \0 l& Q for (int i = 0; i < pNewArray->GetSize(); i++) SetAt(nStartIndex + i, pNewArray->GetAt(i)); } $ e( E8 O& }) X1 E) q} template<class TYPE, class ARG_TYPE> $ A* @* m& u* Z8 V6 Z$ ^) wvoid YCArray<TYPE, ARG_TYPE>::InsertAt(ARG_TYPE newElement, int nIndex,CString cIndex) 3 D& ?% q' z& q+ x/ O t; t{ ADDIndex(cIndex,nIndex+1); InsertAt(newElement,nIndex); } template<class TYPE, class ARG_TYPE> void YCArray<TYPE, ARG_TYPE>::Serialize(CArchive& ar) { & k" W U) Y; X ]+ G* V4 v9 z ASSERT_VALID(this); # m) l5 w/ @5 A# l throw("/*wait for me --- yzhlinux*/"); CObject::Serialize(ar); 6 j" N# v! O/ S if (ar.IsStoring()) { ar.WriteCount(m_nSize); } else / z9 P% i6 ^1 g- x, l+ L4 t2 } { , B0 K* O' G+ U6 D DWORD nOldSize = ar.ReadCount(); 1 t6 z- ]; r; ?& K4 q) X SetSize(nOldSize, -1); f& a9 B6 ^* O Q: P4 u/ t9 |2 n: A } //SerializeElements<TYPE>(ar, Ym_pData, m_nSize); }

#ifdef _DEBUG ' k% a+ }9 f/ b$ t- y! O3 Itemplate<class TYPE, class ARG_TYPE> void YCArray<TYPE, ARG_TYPE>::AssertValid() const { CObject::AssertValid();

if (Ym_pData == NULL) 6 b% E+ a2 S/ Q- O! b, C" [/ p { ASSERT(m_nSize == 0); ASSERT(m_nMaxSize == 0); } * v4 f( O, i- `# m `+ W else 7 ~7 a" }% n4 x" P2 j) T. t { 4 |$ l5 O \5 u2 J" H3 k1 Z; r ASSERT(m_nSize >= 0); ( g q r- L! s/ @, }, q' Y2 i ASSERT(m_nMaxSize >= 0); ASSERT(m_nSize <= m_nMaxSize); / M) Q0 z @# ]8 d ASSERT(AfxIsValidAddress(Ym_pData, m_nMaxSize * sizeof(TYPE*))); } } 4 ]. T. } v4 T$ |, m, ?template<class TYPE, class ARG_TYPE> void YCArray<TYPE, ARG_TYPE>:ump(CDumpContext& dc) const 7 X. s k' _ s ^{ CObject:ump(dc); 1 M& g& x W0 V4 G' p% Uthrow("/*wait for me --- yzhlinux*/"); 7 C, v2 D- ]( ~9 V7 m# G dc << "with " << m_nSize << " elements"; if (dc.GetDepth() > 0) { ' a# {' O6 n6 h+ x, ]. S dc << "\n"; /*wait for me --- yzhlinux*/// DumpElements<TYPE>(dc, Ym_pData, m_nSize); }

dc << "\n"; } 1 @3 u( n& a7 h$ `8 V2 G, M#endif

#endif

//完

Eagle

太长了点，叶师兄应该打包上传的。

yzhlinux

以下是引用Eagle在2005-1-10 14:44:00的发言： 太长了点，叶师兄应该打包上传的。

, P+ e% x- ^: a: ] M2 U, j * Q, V1 m4 ` W3 I; s# n# y 就是因为发不了文件啊，奇怪，现在不能上传文件了，不然不用那么辛苦 ' g( C; e# h% j# s9 L

Eagle

先传到帖图区……

管理员

赚帖子不好吗

yzhlinux

现在可以传文件了，附上，好用的摸板数组类，支持 ATL 可以在任何地方使用。
4 s& z7 U: X* m0 `$ @
  `  _1 N# f" b% A+ w E2mkAVvk.rar (4.61 KB, 下载次数: 19)

2005-6-3 14:56 上传

点击文件名下载附件
一个方便好用的数组类
下载积分: 下沙币 -1 元

游侠无极限

std::map 模板的作用好像就是这样的……