一个方便好用的数组类

yzhlinux

to Whanxy

int N; N=StrToInt(Edit1->Text); int RESULT[N]; 哈哈,这样的代码很有意思哦. 在c++里没有现成的类似vb的redim那样可以自由定义数组边界的办法,很多人提供了一些数组类以实现你这样的需求,同样微软也提供了这样的模板类 CArray ,你可以去参考这个摸板,不过 CArray 写的不够好只能给单线程的地方使用(后来个跟踪进去才发现是它的问题,没把偶气死)并且不能很好的支持使用 & 引用内部的成员(底层机制的问题),我从新改写了它的底层实现,写了一个摸板类,给你用正好满足你的需求.: ; a1 j! u" p0 b: A+ B$ L8 T* Y( P#if !defined(CYCArray_INCLUDED) 7 }8 @) E: A: b0 b/ y#define CYCArray_INCLUDED & {& [2 u$ H/ x: f7 r0 |) ]: @#include "afxtempl.h" 0 m0 j4 Y( \0 V" Y/** * ]! y" w& m; i$ p8 U D* 动态数组的模板类 (Write By yzhlinux ,you could use it any time any way if you could email me about it yzhlinux@hotmail.com) * 1.支持字符索引 * 2.方便的添加删除修改任意一项 * L2 h- W. e7 W5 J4 e9 O! @/ c4 x, e* 最后更新 2004-8-9 3 T) d7 z( b! c% u1 [9 o**1.优化了字符索引的运作方式，使用数组存储 **2.重写了底层数据的存储，将连续性的存储方式改为了非连续, : b3 }! w7 j0 D3 h! r*** 从而很好有效地支持了“引用”,并且让数据的删除增加变的更为快速 ///// K+ {* V5 D7 d- C- F* 用法句举例1： * YCArray<int,int> test1 ; * test1.Add("Number2",4); , ^/ n# H" T+ ? i$ o; i* test1.Add("Number1",2); * printf("%d %d",test1["Number1"],test1["Number2"]); * 显示： / {/ X M; [: T. `* 2 4 - x7 o& y) E, u7 u1 C. Y5 \///// * 用法句举例2： 6 U$ v8 H% O; ~! g+ Y* 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]); $ P- m: N; ^. K' O# _5 n& ?# R* 显示： 9 o6 s. Q3 V7 H% R6 `* yes yes yes yes hahahaha yes yes yes yes 5 X$ |( t& J; \* U8 Q///// @) T- ?& j5 R4 D! R4 u* 用法句举例3: * YCArray<CString,CString> test3 ; * test3.Add("string2","hahahaha"); . M8 M( e3 X1 w# L5 [* test3.Add("string1","yes yes yes yes"); . t0 a7 _" d* [. T* test3.Add("","no no no"); / s+ B- B7 P- o. R* test3.AddR("string2","yes yes yes yes"); //AddR方法会去搜索字符索引，如果存在则替换 * ?- X2 k' m( u# a0 j* printf("%s %s %s",test3["string1"],test3["string2],test3[2]); ( K% h6 h; J$ f+ j2 [5 j* 显示： * yes yes yes yes yes yes yes yes no no no 4 M# V! I- l" ^4 z* Y o' I**/ 2 p, o+ F" T1 a6 A5 ^- a///////////////////////////////////////////////////////////////////////////// // YCArray<TYPE, ARG_TYPE> 2 f- M. z; E5 F8 S% a#include <afxmt.h> template<class TYPE, class ARG_TYPE> class YCArray : public CObject 8 }! `3 f9 |+ T h J U{ & h4 v8 R4 {5 S6 n: D- H//friend YCArray<TYPE, ARG_TYPE>; CCriticalSection YCArray_Add; public: 3 N/ ?. T: m7 k% c, ]// Attributes int GetSize() const; int GetUpperBound() const; void SetSize(int nNewSize, int nGrowBy = -1);

1 d- V: H; y: Q6 x3 G+ Q0 M

// Operations // Clean up 6 p' h; f5 K @& q$ F$ D" S) ]void FreeExtra(); : \8 @; r. n( U: ~% j7 Tvoid RemoveAll();

// Accessing elements 1 o: n' B" |/ o# o! s3 ]% n4 aTYPE GetAt(int nIndex) const; # }* b; f y1 \" {. n3 H8 a Nvoid SetAt(int nIndex, ARG_TYPE newElement); TYPE& ElementAt(int nIndex);

TYPE GetAt(CString cIndex) const; void SetAt(CString cIndex, ARG_TYPE newElement); ; m& w. s. e) Q6 L' |+ y# FTYPE& ElementAt(CString cIndex);

// Direct Access to the element data (may return NULL) const TYPE** GetData() const; ; W6 V/ p, W# W- |* z, Z( V( eTYPE** GetData();

3 w6 k: X5 L: R9 h% x) s& @

// Potentially growing the array 2 [) e$ S4 X/ f1 o! m8 _' \0 uvoid SetAtGrow(int nIndex, ARG_TYPE newElement); . W$ z$ q' p! p; A- ivoid SetAtGrow(CString cIndex, ARG_TYPE newElement); int Add(ARG_TYPE newElement,CString cIndex = ""); + c0 e# Q8 Y/ {' f5 E& Iint AddR(ARG_TYPE newElement,CString cIndex = "")//如果存在就替换 { ) a: y6 {9 ^0 O' U int nIndex = GetIndex(cIndex); ! n1 e, w9 D* H$ v- d if(cIndex!=""&&nIndex >-1){ a2 U" \5 r- s operator[](nIndex)=newElement; % q0 ` T, X' ^& K- f. W }else{ - B+ d. O# F* Y3 j! n0 z( j9 t' d nIndex = m_nSize; SetAtGrow(nIndex, newElement); + a4 Z# u; W. R: b. \& L0 k SETIndex(cIndex,nIndex); , V7 v$ P6 L! q- x" [! L return nIndex; D* J" d% Y8 S. V% b# o v } } $ J6 h- [ _. Nint AddM(ARG_TYPE newElement,CString cIndex = "") 2 R: T! y0 t5 F' V% d{ static int nIndex ; YCArray_Add.Lock(); 5 d4 h6 u; C1 @% F& I" { nIndex = m_nSize; 7 L: t( W' V: L: Z SetAtGrow(nIndex, newElement); YCArray_Add.Unlock(); 4 e1 N; i* m, i3 L8 v9 L9 K/ j SETIndex(cIndex,nIndex); return nIndex; }; int Append(const YCArray& src); ! D* ?% t- }" ]6 D# c' @- L# q; q. L) yvoid Copy(const YCArray& src);

; p8 g8 A, y, q" _* M" U; I

// overloaded operator helpers TYPE operator[](int nIndex) const; TYPE& operator[](int nIndex); TYPE operator[](CString cIndex) const; TYPE& operator[](CString cIndex); ( w! B3 F. \& k' Y//YCArray<TYPE,ARG_TYPE> operator=(YCArray<TYPE,ARG_TYPE>& tparr)const; YCArray<TYPE,ARG_TYPE>& operator=(YCArray<TYPE,ARG_TYPE>& tparr); // Operations that move elements around void InsertAt(int nIndex, ARG_TYPE newElement, int nCount = 1); ; C3 Z. y! r. Wvoid RemoveAt(int nIndex, int nCount = 1); void RemoveAt(CString cIndex,int nCount = 1); 5 }* {$ [' q. Cvoid InsertAt(int nStartIndex, YCArray* pNewArray); ! W8 Q2 ^/ I( Svoid InsertAt(ARG_TYPE newElement,int nIndex,CString cIndex);

int GetIndex(CString cIndex); 9 K9 s* h/ Z, c# tCString GetIndex(int nIndex);

CString GetSign(); 8 O5 K8 @3 h+ u/ o3 z5 ]2 cint SetSign(CString& sign);

. E7 s' \( e: j1 t6 ]

// Implementation 2 _4 d% ^& X. ~3 }protected: 0 W" w+ A( m3 U7 eTYPE** Ym_pData; // the actual array of data ( P- T4 z5 J1 @1 Bint m_nSize; // # of elements (upperBound - 1) int m_nMaxSize; // max allocated int m_nGrowBy; // grow amount private: int lock_sign; 7 j' |1 ^% C6 `( k( j% MCString Sign; int MAXSIGNTIME;

8 F* }6 |& h3 ^- h# d

CString* strIndex; int strIndexNum; BOOL SetIndexSize(int nIndex); 9 S' w& p7 v2 B9 P4 \+ G7 TBOOL SETIndex(CString cIndex,int nIndex); BOOL INSERTIndex(int nIndex,int nCount =1); " H) I5 N6 w* Y: |BOOL DELIndex(int nIndex,int nCount = 1); BOOL DELIndex(CString cIndex,int nCount = 1); void DestructAllElement(int nIndex,int nCount) {//销毁对象，包括每个指针指向的对象 - S+ j- V5 P) }& ^, R: g DELIndex(nIndex,nCount); ASSERT(nIndex >= 0); ASSERT(nCount >= 0); ASSERT(nIndex + nCount <= m_nSize); if(nCount>0&&m_nSize>0){ for(int i =nIndex;i<nIndex+nCount;i++){ + F; i H" n2 o& M' v* Q" d! q //Ym_pData->~TYPE(); // 由于ConstructAllElements 中是 Ym_pData[nIndex] = new TYPE;所以不需要Ym_pData->~TYPE() delete Ym_pData; 8 c# e% @ r! }7 [9 V } } ' |0 M0 B4 k) s& J3 H8 g/ U}; ! z* p) S9 Q3 Rvoid ConstructAllElements(int nIndex,int nCount) . w7 E" ^: o1 T{//创建对象，包括 new 出每个指针指向的对象 1 v. I) X. {" d0 }9 a1 \, h7 s //nIndex = 0; * s" W1 R, K2 f. t4 v# }; H memset((void*)(Ym_pData+nIndex), 0, nCount * sizeof(TYPE*)); ! Z3 q( W' X: c0 U) V& f9 U+ M b2 K for (; nCount--; nIndex++) Ym_pData[nIndex] = new TYPE; / e5 M, z3 G4 h" n t$ s/ g$ F}; public: // Construction 6 v# ^" Y5 Y' V$ WYCArray(); # n6 E, t; K/ U7 X0 BYCArray(YCArray<TYPE, ARG_TYPE>& tp); 0 I3 t, [4 H# d: ^4 p~YCArray(); $ Q: w, n6 D) o3 D* c q" Wvoid Serialize(CArchive&); #ifdef _DEBUG : A! d. w. m$ `( K x8 Nvoid Dump(CDumpContext&) const; void AssertValid() const; #endif

! [' @* ?. A, [+ M; c

};

- T- j: {# y( I6 q% ~- q) l" W

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

yzhlinux

//接上面

$ i: T* P3 [2 W, vtemplate<class TYPE, class ARG_TYPE> YCArray<TYPE, ARG_TYPE>::~YCArray() { ASSERT_VALID(this);

if (Ym_pData != NULL) / o. }1 @% `6 g( s1 v# E { DestructAllElement(0,m_nSize); ( i- D5 j* I: V# T# w$ ^ //DestructElements<TYPE>(Ym_pData, m_nSize); 6 Z5 e i2 A9 w* p, l delete[] (BYTE*)Ym_pData; } - J' d0 \( D7 l8 a/ h0 @} template<class TYPE, class ARG_TYPE> / y3 X3 J3 x$ V. ~: N; e3 a# GCString YCArray<TYPE, ARG_TYPE>::GetSign() * k% [/ N' a" a2 e{ " `# ~% w2 s' f- w; d# o9 h lock_sign=0; return Sign; } 2 c, b# Z7 v! ~9 b" C, ktemplate<class TYPE, class ARG_TYPE> 3 O! x4 y5 Z2 e c. ]int YCArray<TYPE, ARG_TYPE>::SetSign(CString& sign) . o0 `. \" r3 I1 t) t& @{ int i=0; while(lock_sign&&i<MAXSIGNTIME){ Sleep(1); & ]& d- X& A0 o' b7 P/ X i++; ' m& ], U7 j* ?5 _' q& Y: D. V1 v } / y: r6 u0 J7 D' F/ O4 }. B lock_sign=1; 9 y. H$ E" q; W4 } Sign=sign; 8 H& W7 A0 ^% O4 T+ w& p# f return TRUE; 0 y$ {: g1 j4 Y- x& c} $ ^' o+ ~+ `& l% s//用与把 nindex 后的索引往后推 nCount ,自动调整好buffer template<class TYPE, class ARG_TYPE> " L% M1 f5 U3 ?" H- v! sBOOL YCArray<TYPE, ARG_TYPE>::SetIndexSize(int nNewSize) { 3 F3 ~) C. N& a$ {9 Y( ` if(strIndexNum < nNewSize){ CString* tp = new CString[nNewSize];//新的buffer * x$ l/ l. ]. J6 C2 g. P( L for(int i=0;i<strIndexNum;i++){//把老索引复制过来 tp = strIndex; } for(i=strIndexNum;i<nNewSize;i++){ . k& o( h7 b7 p! m$ Y+ C% \1 | tp = "" ; } . [' L9 \ T0 l! H4 h6 J/ a0 G delete[] strIndex ; strIndex = tp ; ( F4 A2 T! `( R* D- q" ]5 b strIndexNum = nNewSize ; }else if(strIndexNum < nNewSize){ # l3 U8 u4 L* \% W0 b for(int i=nNewSize;i<strIndexNum;i++){ 8 G. B9 [: ]: b% { strIndex = "" ; } 4 M# w6 S, W$ S7 p } return TRUE; + M2 t6 b" i6 L$ ?} template<class TYPE, class ARG_TYPE> " d9 [5 X6 v5 ]5 q" sBOOL YCArray<TYPE, ARG_TYPE>::INSERTIndex(int nIndex,int nCount /*=1*/) 4 b) B& d/ P# Y8 i{ CString* tp = new CString[m_nSize+nCount];//新的buffer - R9 |! t) {" B. c, b+ M for(int i=0;i<nIndex;i++){//把老索引复制过来 tp = strIndex; / w( n# M1 A* ^- T& m+ o }int j =0 ; & F* n! C& ~6 H$ e4 [ for(i=nIndex+nCount;i<m_nSize;i++){//把老索引复制过来 ; [# r5 v+ ^1 r* p2 S2 Y tp = strIndex[nIndex+j]; 5 H. P: B+ M. w9 o j++; } delete[] strIndex ; ( a" ~* f4 x6 l$ x( q' v- C strIndex = tp ; return TRUE; # l/ q0 ]( p+ w3 `1 {} template<class TYPE, class ARG_TYPE> BOOL YCArray<TYPE, ARG_TYPE>::SETIndex(CString cIndex,int nIndex) {//在 nIndex 后面添加一个 字符串索引 " ]- Y9 e" W1 e+ z4 W2 ~ strIndex[nIndex] = cIndex ; 9 ~- f6 ]3 c( g- t8 u return TRUE; 2 c" F7 b) ~: F' @0 _7 m; b6 X} template<class TYPE, class ARG_TYPE> BOOL YCArray<TYPE, ARG_TYPE>:ELIndex(int nIndex,int nCount /*=1*/) 1 N8 S# W5 y6 k! C0 l2 k{//需要在 m_nSize 变化之前调用!! ASSERT(nIndex >= 0); ) I3 d% I9 K7 b- [8 J' V2 z# | ASSERT(nCount >= 0); $ j3 J# \. `. P+ m7 G ASSERT(nIndex + nCount <= m_nSize); & q8 t; T, O$ A P/ I: i1 D int j =0 ; 4 J H% z1 Q$ r for(int i=nIndex+nCount;i<m_nSize;i++){//把老索引复制过来 # y% v* }8 D1 c( [5 N strIndex[nIndex+j] = strIndex; j++; } 5 K- }% k( \6 U% \2 r9 { return TRUE; # z; O7 [& Y) p2 ?# l5 a. n9 a+ B2 f} template<class TYPE, class ARG_TYPE> * z! l: W- A( ?9 J$ W4 IBOOL YCArray<TYPE, ARG_TYPE>:ELIndex(CString cIndex,int nCount /*=1*/) { - n+ @- M0 F# p6 @9 M int nIndex=this->GetIndex(cIndex); 8 h4 P% m4 B, v0 p+ D O return this->DELIndex(nIndex,nCount); * h7 n. @ v4 C. B} 9 g: a" o' ^# W/ d% m. ?( mtemplate<class TYPE, class ARG_TYPE> int YCArray<TYPE, ARG_TYPE>::GetIndex(CString cIndex) ' Y! O4 ]$ M8 B# \/ a0 K$ Z) y{//得到 cIndex 的数字索引 int nPos = -1; for(int i=0;i<m_nSize;i++){ 8 U$ v- }; y! F1 M6 |2 V if(strIndex == cIndex){ nPos = i ;break; } } ' t# j& l1 ^- n5 O0 G2 f return nPos; , ?) ~% [& v* C1 U& H6 B2 C} : b, r! I' S( R. Dtemplate<class TYPE, class ARG_TYPE> CString YCArray<TYPE, ARG_TYPE>::GetIndex(int nIndex) {//返回 nIndex 的字符串索引 return strIndex[nIndex]; 2 o5 m+ ]2 _- x9 n U7 C/ e} 6 z7 F( g3 v3 [ r) U; d+ D; ]///////////////////////////////////////////////////////////////////////////// // YCArray<TYPE, ARG_TYPE> inline functions

template<class TYPE, class ARG_TYPE> # {% `4 o% p8 \7 a( Y7 ^AFX_INLINE int YCArray<TYPE, ARG_TYPE>::GetSize() const { return m_nSize; } I# m X9 n: m5 dtemplate<class TYPE, class ARG_TYPE> 3 v& ^$ g3 n# r( R4 DAFX_INLINE int YCArray<TYPE, ARG_TYPE>::GetUpperBound() const { return m_nSize-1; } template<class TYPE, class ARG_TYPE> AFX_INLINE void YCArray<TYPE, ARG_TYPE>::RemoveAll() 9 ]* q, ~+ s% d2 F { SetSize(0, -1); } - A7 v, J/ ~8 Q# {template<class TYPE, class ARG_TYPE> / v, p7 O8 ^( T$ E- {+ _9 ?8 ?AFX_INLINE TYPE YCArray<TYPE, ARG_TYPE>::GetAt(int nIndex) const { ASSERT(nIndex >= 0 && nIndex < m_nSize); return *Ym_pData[nIndex]; } ) c2 e5 S& `& H: d% e. m- h# utemplate<class TYPE, class ARG_TYPE> ) Q: i7 ~9 x0 bAFX_INLINE void YCArray<TYPE, ARG_TYPE>::SetAt(int nIndex, ARG_TYPE newElement) 1 S- U) \3 ~! W6 w* w/ A1 o7 } { 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) { ASSERT(nIndex >= 0 && nIndex < m_nSize); return *Ym_pData[nIndex]; }

template<class TYPE, class ARG_TYPE> TYPE YCArray<TYPE, ARG_TYPE>::GetAt(CString cIndex) const { # c: V& ]* a2 r int nIndex=GetIndex(cIndex); * s9 {& {4 ^( o return GetAt(nIndex); } 6 o* [& H: M, ^( ztemplate<class TYPE, class ARG_TYPE> 3 o6 O* } _% Z6 C& F! Y ovoid YCArray<TYPE, ARG_TYPE>::SetAt(CString cIndex, ARG_TYPE newElement) { - O+ }! f6 X# b% D7 u int nIndex=GetIndex(cIndex); 8 H3 l" i' r) n5 y% H6 y return SetAt(nIndex, newElement); 3 Q. f8 _; Z4 {3 u% `% u} template<class TYPE, class ARG_TYPE> - k* J2 ^9 H6 f/ n3 ^ tTYPE& YCArray<TYPE, ARG_TYPE>::ElementAt(CString cIndex) { int nIndex=GetIndex(cIndex); 6 a+ V3 a3 T$ |% A7 h. U2 Z return ElementAt(nIndex); $ {% x. z/ G2 c) U* J} $ ^% z+ |$ m" Rtemplate<class TYPE, class ARG_TYPE> 4 R5 B- ?% Z! y, k+ s! [7 \) ^AFX_INLINE const TYPE** YCArray<TYPE, ARG_TYPE>::GetData() const $ J5 _1 S: _* X) q4 R9 m# S# ^ { return (const TYPE**)Ym_pData; } . u5 T. c9 W$ Y6 N+ U! b( gtemplate<class TYPE, class ARG_TYPE> / z9 R0 f) B( `7 ?+ e, L6 KAFX_INLINE TYPE** YCArray<TYPE, ARG_TYPE>::GetData() & ]4 [2 ^8 j- ?- z2 W" h { return (TYPE**)Ym_pData; } % w) _6 ^: G6 ^; |& Y* {template<class TYPE, class ARG_TYPE> s% C8 z5 ~, o( L0 d4 G* BAFX_INLINE int YCArray<TYPE, ARG_TYPE>::Add(ARG_TYPE newElement,CString cIndex /* ="" */) 5 Q* K- ]/ s; k' ^0 o9 y+ m { int nIndex = m_nSize; SetAtGrow(nIndex, newElement); SETIndex(cIndex,nIndex); 2 N" v( {- `, p- w) ~8 ? return nIndex; } template<class TYPE, class ARG_TYPE> ' H0 k9 H2 q& c! pAFX_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) 4 X9 @4 a; K% ^& u, l) K9 |" E { return ElementAt(nIndex); } template<class TYPE, class ARG_TYPE> 4 J5 L! w8 o5 s% V% uAFX_INLINE TYPE YCArray<TYPE, ARG_TYPE>:perator[](CString cIndex) const 9 _# b5 G2 j0 q$ s6 g; g{ int nIndex=GetIndex(cIndex);

return operator[](nIndex); " G# M; A) w6 k2 i4 S} : c- w) {5 v7 d9 ttemplate<class TYPE, class ARG_TYPE> & }! \: q( D ^' T( L2 mAFX_INLINE TYPE& YCArray<TYPE, ARG_TYPE>:perator[](CString cIndex) { ! `6 V; K6 S- m g5 @& S1 g int nIndex=GetIndex(cIndex); return operator[](nIndex); 3 f0 V% o% k; M) _7 [} /* template<class TYPE, class ARG_TYPE> 9 j1 e* v- E; m% C/ o# FAFX_INLINE YCArray<TYPE,ARG_TYPE> YCArray<TYPE, ARG_TYPE>:perator=(YCArray<TYPE,ARG_TYPE>& tparr) const { int i,j; $ x. b) F3 ]& r, h4 C for(i=0;i<tparr.GetSize();i++){ 6 |/ o! G' H! Y4 f" ~, ^ j = GetIndex(tparr.GetIndex(i)); if(j>-1){ operator[](tparr.GetIndex(i)) = tparr; & A* J9 \5 @+ r) Q; D* p } }else{ 5 ?; w1 O9 y% s7 p Add(tparr,tparr.GetIndex(i)); 1 j, ]) e; q; k1 |4 [ } a/ ^8 _2 w$ k* ?7 w0 G, N } 0 p2 J$ K9 v$ F( {4 S: t% @ return this; } 8 `& Q7 A& f; f$ K& \3 E1 ?8 g3 S*/ template<class TYPE, class ARG_TYPE> ( y. z0 i6 x- Y) ?5 zAFX_INLINE YCArray<TYPE,ARG_TYPE>& YCArray<TYPE, ARG_TYPE>:perator=(YCArray<TYPE,ARG_TYPE>& src) " N4 a4 p; R1 A. U$ s/ Q8 Y0 S, m{ ASSERT_VALID(this); / h8 _! ]4 P0 W6 c, V5 H* A ASSERT(this != &src); // cannot append to itself

SetSize(src.m_nSize); ; ]/ e' u* W; l8 @ for(int i=0;i<m_nSize;i++){ /*将此句修改为内存拷贝*/// $ l4 v8 k- y6 Q3 @4 H *Ym_pData = *src.Ym_pData ; , W- G1 Y2 p, X, l9 L //memcpy(Ym_pData,src.Ym_pData,sizeof(TYPE)); " ~, u4 x4 \8 m0 U, O0 j+ _ SETIndex(src.GetIndex(i),i); * M, A6 w* y0 |: g } ' D. R0 K* q; J! A. V% E) B! C return *this; J+ K. y, V6 u2 A3 ^9 x! p. g. U} ' ?+ t5 ^+ P1 G! m! w. d/ x///////////////////////////////////////////////////////////////////////////// + J! _* V$ h# S4 M4 ?// YCArray<TYPE, ARG_TYPE> out-of-line functions

template<class TYPE, class ARG_TYPE> 7 b3 X* |0 T/ v9 u3 VYCArray<TYPE, ARG_TYPE>::YCArray() { . b7 X- I9 S9 t" ^( n: L Ym_pData = NULL; ( v4 ?4 K# T* V7 | z strIndexNum = m_nSize = m_nMaxSize = m_nGrowBy = 0; ! I' |( `8 w0 l, K; T# A strIndex=NULL;MAXSIGNTIME=10; 1 I$ ]; y) ~% \6 {} ; V9 I/ v- |3 ?- otemplate<class TYPE, class ARG_TYPE> YCArray<TYPE, ARG_TYPE>::YCArray(YCArray<TYPE, ARG_TYPE>& tp) _& _; l x7 f{ Ym_pData = NULL; strIndexNum = m_nSize = m_nMaxSize = m_nGrowBy = 0; strIndex=NULL;MAXSIGNTIME=10; & C; L( Y. S% g3 J" S6 L3 T operator=(tp); }

template<class TYPE, class ARG_TYPE> 8 p. U' [! P; w7 ?void YCArray<TYPE, ARG_TYPE>::SetSize(int nNewSize, int nGrowBy) { 4 i' p& L0 @: k ASSERT_VALID(this); ; w) U/ z$ h4 T$ T ASSERT(nNewSize >= 0);

if (nGrowBy != -1) m_nGrowBy = nGrowBy; // set new size

if (nNewSize == 0){ // shrink to nothing : F( T" b2 } S0 o4 W if (Ym_pData != NULL){ DestructAllElement(0,m_nSize); //DestructElements<TYPE>(Ym_pData, m_nSize); delete[] (BYTE*)Ym_pData; ) n" R5 W3 F- v Ym_pData = NULL; - k) z- E! O. x, ?/ z& C } 1 J5 _4 c2 ~+ l G; q# i m_nSize = m_nMaxSize = 0; . x+ d6 N0 }) Y3 Y0 m } else if (Ym_pData == NULL){ // create one with exact size #ifdef SIZE_T_MAX 1 D+ {7 `$ W) A7 s/ ]1 m& { ASSERT(nNewSize <= SIZE_T_MAX/sizeof(TYPE*)); // no overflow , W) [! T% B% ~+ X#endif ( g3 j9 e; E. d Ym_pData = (TYPE**) new BYTE[nNewSize * sizeof(TYPE*)]; ConstructAllElements(0,nNewSize);//ConstructElements<TYPE>(Ym_pData, nNewSize); ; G$ S' Y. w! t' N m_nSize = m_nMaxSize = nNewSize; + L8 ^0 S9 j# E2 t/ l } else if (nNewSize <= m_nMaxSize){ 7 i* Z, E6 W2 q+ q& }; E; C/ M // it fits if (nNewSize > m_nSize) 8 u- j n, @8 P4 @ { " f; H. F& d, [$ Z- z/ [ // initialize the new elements u, |0 V5 s, A J% @3 A& { ConstructAllElements(m_nSize,nNewSize-m_nSize);//ConstructElements<TYPE>(&Ym_pData[m_nSize], nNewSize-m_nSize); / c2 f. b) t1 k- I } , J( W! G9 q3 Q# X$ z! ?( S else if (m_nSize > nNewSize) , w' w: g; D4 h4 M& Q- V" u { // destroy the old elements ( }0 _8 q; |2 R* E) Y! n DestructAllElement(nNewSize,m_nSize-nNewSize); - w, z) |0 _$ j //DestructElements<TYPE>(&Ym_pData[nNewSize], m_nSize-nNewSize); } m_nSize = nNewSize; } else { 3 D) |3 {! R* e, c/ j5 r4 U // otherwise, grow array int nGrowBy = m_nGrowBy; if (nGrowBy == 0) { 4 q. ~5 |9 |* T5 V // heuristically determine growth when nGrowBy == 0 ! g* z7 o/ i: P8 f: W, R! W' Z // (this avoids heap fragmentation in many situations) 3 a6 ^0 x# l' q3 s' r, \ nGrowBy = m_nSize / 8; nGrowBy = (nGrowBy < 4) ? 4 : ((nGrowBy > 1024) ? 1024 : nGrowBy); } int nNewMax; if (nNewSize < m_nMaxSize + nGrowBy) nNewMax = m_nMaxSize + nGrowBy; // granularity # h; C# W7 r7 I else - q* }# j+ @6 N- z6 y. r nNewMax = nNewSize; // no slush

ASSERT(nNewMax >= m_nMaxSize); // no wrap around #ifdef SIZE_T_MAX ASSERT(nNewMax <= SIZE_T_MAX/sizeof(TYPE)); // no overflow ! U! ?4 y+ B# T& ~#endif % K1 i- F5 J8 K+ ] u TYPE** pNewData = (TYPE**) new BYTE[nNewMax * sizeof(TYPE*)];//TYPE* pNewData = (TYPE*) new BYTE[nNewMax * sizeof(TYPE)];

// copy new data from old memcpy(pNewData, Ym_pData, m_nSize * sizeof(TYPE*));

// construct remaining elements ASSERT(nNewSize > m_nSize); //throw("/*wait for me --- yzhlinux*/"); delete[] (BYTE*)Ym_pData; , y$ b; ?/ U I- F" g" |2 n4 I Ym_pData = pNewData; + ~( \ E: X, a2 D, l; H ConstructAllElements(m_nSize,nNewSize-m_nSize);//ConstructElements<TYPE>(&pNewData[m_nSize], nNewSize-m_nSize);

// get rid of old stuff (note: no destructors called) m_nSize = nNewSize; * h/ f8 e8 q- C5 `. h4 S m_nMaxSize = nNewMax; } " R4 H/ \% w9 s0 B. e' b SetIndexSize(nNewSize); " s; u' g3 ^$ D- g' N$ z+ K}

yzhlinux

//接上面

. l5 }; [2 W+ M" I5 ctemplate<class TYPE, class ARG_TYPE> int YCArray<TYPE, ARG_TYPE>::Append(const YCArray& src) ( y6 Q$ l/ F' Z7 j* c* f/ ~8 T; w% G{ ASSERT_VALID(this); / I/ v7 L" E9 M; x/ h8 Y1 t6 l2 }1 \ ASSERT(this != &src); // cannot append to itself

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

ConstructAllElements(nOldSize,src.m_nSize); 5 I% a- H- H+ F& J; C6 W L7 ? 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)); 6 H3 s/ b2 l( I* ~ SETIndex(src.GetIndex(i-nOldSize),i); } /*wait for me*///CopyElements<TYPE>(Ym_pData + nOldSize, src.Ym_pData, src.m_nSize); 3 X* W0 N8 v: P$ v% s0 o return nOldSize; % r8 C/ m, T) n+ c6 T}

template<class TYPE, class ARG_TYPE> 5 Z5 i1 q0 F- [( O: Mvoid YCArray<TYPE, ARG_TYPE>::Copy(const YCArray& src) , U1 e; ^3 ^) `4 E/ v \ j{ 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)); & t+ }& S; ~ b0 S3 y/ L SETIndex(src.GetIndex(i),i); } /*wait for me*///CopyElements<TYPE>(Ym_pData, src.Ym_pData, src.m_nSize); }

template<class TYPE, class ARG_TYPE> 0 o/ X; R9 M6 Hvoid YCArray<TYPE, ARG_TYPE>::FreeExtra() { ( C$ H- Y( q9 g: q4 K, v& k ASSERT_VALID(this);

if (m_nSize != m_nMaxSize) { 9 [. a: V% b. r: j! m // shrink to desired size #ifdef SIZE_T_MAX ASSERT(m_nSize <= SIZE_T_MAX/sizeof(TYPE)); // no overflow #endif TYPE* pNewData = NULL; if (m_nSize != 0) { 4 f& X* ?1 A6 O pNewData = (TYPE**) new BYTE[m_nSize * sizeof(TYPE*)]; // 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; Ym_pData = pNewData; 1 D% z+ R' J6 b" I2 v. U* z m_nMaxSize = m_nSize; } ) W q5 o6 H1 S5 c: }: N} 8 F3 F. K2 E. E. M% Mtemplate<class TYPE, class ARG_TYPE> void YCArray<TYPE, ARG_TYPE>::SetAtGrow(CString cIndex, ARG_TYPE newElement) { - ?% O( U+ ^7 S/ v# v M int nIndex=GetIndex(cIndex); return SetAtGrow(nIndex,newElement); 4 P( _+ J$ N5 [( W} ! f* i% z. ]1 E% S1 n0 Ztemplate<class TYPE, class ARG_TYPE> void YCArray<TYPE, ARG_TYPE>::SetAtGrow(int nIndex, ARG_TYPE newElement) 7 y6 L, M: p) F, M( Q{ 4 f* b- a% g$ o4 ` ASSERT_VALID(this); 0 C5 O" x0 m, _1 ?# @- H ASSERT(nIndex >= 0);

if (nIndex >= m_nSize) # U8 |3 P m/ {, s. T SetSize(nIndex+1, -1); *Ym_pData[nIndex] = newElement; }

template<class TYPE, class ARG_TYPE> void YCArray<TYPE, ARG_TYPE>::InsertAt(int nIndex, ARG_TYPE newElement, int nCount /*=1*/) { ASSERT_VALID(this); * H0 K2 m x4 q ASSERT(nIndex >= 0); // will expand to meet need ASSERT(nCount > 0); // zero or negative size not allowed

if (nIndex >= m_nSize) , P- @" @8 n9 A5 W0 W' ^7 ` { g3 a' |8 r; b // adding after the end of the array 3 {) _; }( S9 b SetSize(nIndex + nCount, -1); // grow so nIndex is valid + G! j+ p- k0 L } . G0 {8 V* q% y$ n else { // inserting in the middle of the array 0 j) b4 _: l3 X$ t; y- X, @ int nOldSize = m_nSize; 1 l0 E& c, t- t SetSize(m_nSize + nCount, -1); // grow it to new size 8 J w* S4 N3 k7 r" M( d- g // destroy intial data before copying over it ; [" ?7 J" T* @2 T7 G D! C /*不需要销毁了,因为 SetSize 的是指针*///DestructAllElement(nOldSize,nCount); % z2 _0 A5 }0 {" a: p+ o //DestructElements<TYPE>(&Ym_pData[nOldSize], nCount); , g0 R- N4 D+ G1 o8 X6 ~7 v6 k // shift old data up to fill gap 8 s7 J2 g( V3 {. Y5 A memmove(&Ym_pData[nIndex+nCount], &Ym_pData[nIndex], (nOldSize-nIndex) * sizeof(TYPE*));

// re-init slots we copied from - s" T9 ~( c: y4 T k/ E3 } /*不需要销毁了,因为 SetSize 的是指针*///ConstructAllElements(nIndex,nCount);//ConstructElements<TYPE>(&Ym_pData[nIndex], nCount); }

// insert new value in the gap ASSERT(nIndex + nCount <= m_nSize); # N6 i& N3 G2 h# r7 o while (nCount--){ . ]6 O F7 ? v' O) t E. h *Ym_pData[nIndex++] = newElement; " i4 d( D6 w" ` r } } template<class TYPE, class ARG_TYPE> void YCArray<TYPE, ARG_TYPE>::RemoveAt(CString cIndex,int nCount /*=1*/) $ A- G: V% W( s{ int nIndex = GetIndex(cIndex); RemoveAt(nIndex,nCount); 9 {+ h% a V2 @5 }# U} template<class TYPE, class ARG_TYPE> % R2 g; v" M# V1 S6 \* _8 avoid YCArray<TYPE, ARG_TYPE>::RemoveAt(int nIndex, int nCount /*=1*//*=1*/) { ; \ ?! `: ?: E& J) s q2 q! x" `$ p ASSERT_VALID(this); 5 x6 k9 L! F. f1 {2 {. ^# y4 u+ } ASSERT(nIndex >= 0); / H" J5 B! C0 G5 ]# R$ S ASSERT(nCount >= 0); ASSERT(nIndex + nCount <= m_nSize); //yzh DELIndex(nIndex); ; m" r8 Y* e: O* `) r" j9 v //yzh Y$ x7 V2 E& ]+ l // just remove a range W& w. b" q: ~9 O' P int nMoveCount = m_nSize - (nIndex + nCount); //需要移动的数目 DestructAllElement(nIndex,nCount); ( P3 V5 H$ a3 _0 B8 b //DestructElements<TYPE>(&Ym_pData[nIndex], nCount); if (nMoveCount) 8 e3 \4 T2 ~2 k n+ h memmove(&Ym_pData[nIndex], &Ym_pData[nIndex + nCount], ! J; O" }& ?/ O! y nMoveCount * sizeof(TYPE*)); m_nSize -= nCount; }

template<class TYPE, class ARG_TYPE> void YCArray<TYPE, ARG_TYPE>::InsertAt(int nStartIndex, YCArray* pNewArray) 5 v! b0 L9 ^: l( O" F9 p{ % `. m& G& n7 a5 N% d$ y+ C ASSERT_VALID(this); ASSERT(pNewArray != NULL); O4 h4 G8 D8 y) u1 H+ }" l& C ASSERT_VALID(pNewArray); 1 u4 K5 `# u. R8 Y. d ASSERT(nStartIndex >= 0);

if (pNewArray->GetSize() > 0) * I# u5 B1 z9 M* D/ S { InsertAt(nStartIndex, pNewArray->GetAt(0), pNewArray->GetSize()); 3 S7 _) j* P9 x7 h' y) V for (int i = 0; i < pNewArray->GetSize(); i++) SetAt(nStartIndex + i, pNewArray->GetAt(i)); ' i+ y- b! o# `% a+ B( q- r } / y' U- R* O/ J, B* u} template<class TYPE, class ARG_TYPE> * G$ l6 Y: Y) T `% p7 r* X0 qvoid YCArray<TYPE, ARG_TYPE>::InsertAt(ARG_TYPE newElement, int nIndex,CString cIndex) { ADDIndex(cIndex,nIndex+1); 0 l0 J: k7 t) V& _$ e InsertAt(newElement,nIndex); 2 a; C: }. ?( a* S a5 T& X: r} template<class TYPE, class ARG_TYPE> 9 L# `5 d V. P( Q1 ivoid YCArray<TYPE, ARG_TYPE>::Serialize(CArchive& ar) 8 {! j5 h3 u W; c1 L! `{ & T) w5 ~7 d4 z. U1 B5 O' |; d2 } ASSERT_VALID(this); 5 I: M9 p8 O; q; X3 U, _: i throw("/*wait for me --- yzhlinux*/"); $ l# ~. u# s" _# @ CObject::Serialize(ar); - `; G3 z1 c3 t, I& j: B, X8 c6 e5 K if (ar.IsStoring()) { ar.WriteCount(m_nSize); 7 i% A) W0 M7 n; p _. ? } & a6 H$ K6 `% ~7 a' ~+ P" B else { ( o7 v6 V; b: ~ DWORD nOldSize = ar.ReadCount(); SetSize(nOldSize, -1); 7 U0 P Y) M( u7 P7 R# u; ? } ( g( I, d0 j' Y# o) s //SerializeElements<TYPE>(ar, Ym_pData, m_nSize); ' ~; r' n; O' p! ?}

#ifdef _DEBUG template<class TYPE, class ARG_TYPE> void YCArray<TYPE, ARG_TYPE>::AssertValid() const ( s. Y( V, Z. g" c$ ~/ N{ CObject::AssertValid();

if (Ym_pData == NULL) { ' W6 ^* z! g4 u$ Z5 } ASSERT(m_nSize == 0); ( n5 P! J6 D# S6 { ASSERT(m_nMaxSize == 0); : O0 r, m: t$ b# M } ' ~/ P8 I; w0 R b. z" L, ^+ `& e; r else & r. Y# _4 \& h, E/ o { ASSERT(m_nSize >= 0); 1 k! K6 f9 _ R& J5 Z ASSERT(m_nMaxSize >= 0); 4 y! v; Y# v5 |9 H/ x ASSERT(m_nSize <= m_nMaxSize); ASSERT(AfxIsValidAddress(Ym_pData, m_nMaxSize * sizeof(TYPE*))); / }6 _9 H p; m2 \( a2 O( r+ p } : s7 U+ `2 M5 h7 k% c3 }% a. X; D, Z0 x} 4 }* f7 ]# v' l# |( Z( U% Htemplate<class TYPE, class ARG_TYPE> 6 ]( E% ^# k+ L5 Avoid YCArray<TYPE, ARG_TYPE>:ump(CDumpContext& dc) const ; H; S! {3 Q2 A& T: {) z$ h2 R{ & I( W0 C8 M. a4 `1 ~5 t( D8 b CObject:ump(dc); throw("/*wait for me --- yzhlinux*/"); dc << "with " << m_nSize << " elements"; if (dc.GetDepth() > 0) / R7 v: O' Y# R( N) F8 ^ { dc << "\n"; /*wait for me --- yzhlinux*/// DumpElements<TYPE>(dc, Ym_pData, m_nSize); }

dc << "\n"; } #endif

#endif

//完

Eagle

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

yzhlinux

以下是引用Eagle在2005-1-10 14:44:00的发言： 3 @5 b& C. |- L4 ], N' p7 L6 Q. E2 g太长了点，叶师兄应该打包上传的。

2 i: l0 C% D+ X. Q" s ; K) @: h& I1 a; R9 k* G* M" _2 M , Q; L( `1 t/ N3 q2 [' O5 P4 u就是因为发不了文件啊，奇怪，现在不能上传文件了，不然不用那么辛苦

Eagle

先传到帖图区……

管理员

赚帖子不好吗

yzhlinux

现在可以传文件了，附上，好用的摸板数组类，支持 ATL 可以在任何地方使用。
& G( G+ Q6 q- b- [
E2mkAVvk.rar (4.61 KB, 下载次数: 19)

2005-6-3 14:56 上传

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

游侠无极限

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