|
//接上面 2 Q, U5 R9 I% F. }" f3 ~" Q0 c
template<class TYPE, class ARG_TYPE>' F( `- l% D% Q- P
YCArray<TYPE, ARG_TYPE>::~YCArray() M, r" B0 Z3 w3 Z8 ~5 j
{
- W. X" b9 Q3 B8 {- J' l ASSERT_VALID(this); if (Ym_pData != NULL)( [$ U4 \( Z d7 V5 m1 m) Z/ d
{
# O( V+ z1 U# z/ p6 m7 V2 x0 S, V* N5 ^ DestructAllElement(0,m_nSize);8 v' p& j- [7 h' b: }. U1 a
//DestructElements<TYPE>(Ym_pData, m_nSize);/ a( v7 Y1 u: m6 ^
delete[] (BYTE*)Ym_pData;& R4 f4 K* I* j; H
}- N7 k. F; @+ W1 k2 X8 e
}
8 M2 Q4 ^' I2 W/ j/ Vtemplate<class TYPE, class ARG_TYPE>
6 X) @3 T! F- q0 M# d: pCString YCArray<TYPE, ARG_TYPE>::GetSign()( H5 C% g: u5 H# X% ]% l$ h
{" a2 z- h% I* ]9 h$ g
lock_sign=0;
1 V1 ~: z- {. y) M) T |) u* l return Sign;4 @9 Q5 |" E% ]5 v/ a9 f5 L" k
}
, J$ b m# i, S2 Htemplate<class TYPE, class ARG_TYPE>
$ G1 N4 M% g0 x7 f1 W0 X5 Oint YCArray<TYPE, ARG_TYPE>::SetSign(CString& sign)
4 V/ }& M2 X6 i5 `6 I4 `7 t0 q9 f{
2 ~3 e% a$ q2 O/ ^" x$ N# N; Q int i=0;
* C* o5 s8 H, r# ^+ S while(lock_sign&&i<MAXSIGNTIME){3 c( W' o1 z" ?" G
Sleep(1);
: R& v1 A1 S+ \. L% d) C i++;
) [+ n* T9 }8 p2 V# r& P }( R1 O$ t- n9 q7 z* T
lock_sign=1;* _( W0 P7 z5 c8 s! \( z
Sign=sign;
! A8 G) k* V8 J# J return TRUE;; M0 |, D- g5 e
}
/ c6 O+ }! y* m7 H2 D1 O. m//用与把 nindex 后的索引往后推 nCount ,自动调整好buffer5 Y. J) V1 L+ R1 U
template<class TYPE, class ARG_TYPE>8 q- U6 h$ s: P7 s1 ]% u6 B+ N
BOOL YCArray<TYPE, ARG_TYPE>::SetIndexSize(int nNewSize)
7 A( x: A5 C2 Y' P9 X- w- Y{
+ j2 I O5 p6 S# M3 g, ]- ^ if(strIndexNum < nNewSize){
7 a5 |% h6 y* C/ Q5 ?* b! |1 G0 R CString* tp = new CString[nNewSize];//新的buffer
\+ j5 [! }$ o9 H* W9 g for(int i=0;i<strIndexNum;i++){//把老索引复制过来1 s( f$ \, w- b& L- C# U
tp = strIndex;6 \( K: v! k( d# r. @3 q1 ?
}" C! o$ O4 h% Q
for(i=strIndexNum;i<nNewSize;i++){: G& S* O+ B1 n
tp = "" ;, a0 _' |7 b0 }% H8 l# v
} $ J0 q2 Y) s O
delete[] strIndex ;7 L( s H. c3 [$ q4 Y' O0 y8 O
strIndex = tp ;
- ~0 p. }# ^% m: b6 e. } strIndexNum = nNewSize ;$ r2 b: V3 T& C# c: J% B( q( m! A
}else if(strIndexNum < nNewSize){
" Q4 q1 O U! A: n1 o v. ]# ?2 b for(int i=nNewSize;i<strIndexNum;i++){
3 p& E1 o1 }/ h8 z3 i strIndex = "" ;0 j/ H5 J d* K- y! b \( c
}& s6 s2 m& N4 c% ?8 }# \7 p
}9 t6 y9 r/ w$ ` Z8 ]
return TRUE;# v8 t4 y/ ]& S) h- G& [
} e5 V% ?' s& k
template<class TYPE, class ARG_TYPE>
6 N1 h5 p% J/ D4 t& n7 HBOOL YCArray<TYPE, ARG_TYPE>::INSERTIndex(int nIndex,int nCount /*=1*/)
& t) b9 G3 F( j: J{$ W1 F0 m9 U7 M0 T: i3 m |$ D
CString* tp = new CString[m_nSize+nCount];//新的buffer, y: S% p' ~& g0 D5 C
for(int i=0;i<nIndex;i++){//把老索引复制过来% c4 ]" U$ ~& L
tp = strIndex;
' B" t) }; N" u( |: t: ? }int j =0 ;+ @) o1 ~3 X- O) w8 i4 I: `2 n
for(i=nIndex+nCount;i<m_nSize;i++){//把老索引复制过来
E! N( \0 O/ S: ^9 l2 W tp = strIndex[nIndex+j];1 I4 f* X* X" I6 ~
j++;7 z' N$ a% G3 c- x" J
}
* |8 O: \" E$ n' k A delete[] strIndex ;
; R: m+ U6 g8 ]+ ~ strIndex = tp ;
" T" \2 z! t! u( ]9 \5 i return TRUE;' V7 s2 y! X3 ?+ f4 I" J
}
: T8 p- K' H8 z6 otemplate<class TYPE, class ARG_TYPE>' G; z5 ]; D5 n2 B( T# b
BOOL YCArray<TYPE, ARG_TYPE>::SETIndex(CString cIndex,int nIndex)/ k9 ~" e, d6 ^9 Z3 X
{//在 nIndex 后面添加一个 字符串索引
, s/ P/ W+ ~7 c7 A strIndex[nIndex] = cIndex ;
5 b9 a, t A$ Y; p return TRUE;
7 f' v7 B5 U2 I9 |7 K6 G# m& M}( ]. T$ e5 \% I9 J4 T* V C) e/ T5 j
template<class TYPE, class ARG_TYPE>6 D$ g a" j# o; [
BOOL YCArray<TYPE, ARG_TYPE>: ELIndex(int nIndex,int nCount /*=1*/)
. D6 @: D t# F3 Y. M4 x" }{//需要在 m_nSize 变化之前调用!!( c! @" k( R& l$ u6 c+ ]$ c
ASSERT(nIndex >= 0);* x& I9 E! f) A4 ^2 [
ASSERT(nCount >= 0);7 C% B- h# M4 p9 p4 R
ASSERT(nIndex + nCount <= m_nSize);
5 w3 I/ e/ X2 W2 Y1 N* O# \ int j =0 ;+ a- P5 ~- @% f+ i9 T
for(int i=nIndex+nCount;i<m_nSize;i++){//把老索引复制过来8 \: ]' }' x; r+ n+ J2 V7 w4 x2 }
strIndex[nIndex+j] = strIndex;
+ ~) V+ b, M3 T* {: j" P j++;
2 ~- E. G+ N( k. Z, a/ a }
( b" D& Y) x9 j2 C" q: \5 S4 c. Q+ x return TRUE;# [0 i0 N3 \2 M! b. n. e$ b' o
}( f( B8 X2 B6 L0 H% c' w
template<class TYPE, class ARG_TYPE># D0 H. }# x$ F/ c
BOOL YCArray<TYPE, ARG_TYPE>:ELIndex(CString cIndex,int nCount /*=1*/)" t3 N% b; M9 P# n# k, U6 z
{
V1 f8 Y) r5 E+ h3 k/ I3 b1 h int nIndex=this->GetIndex(cIndex);
) K% I+ T4 S) N return this->DELIndex(nIndex,nCount);; }8 J* k1 [5 V$ Y
}& K6 f9 ^) C9 n! T) L
template<class TYPE, class ARG_TYPE>
4 i U" x/ J1 C5 [4 Jint YCArray<TYPE, ARG_TYPE>::GetIndex(CString cIndex)' y7 G H4 b+ M- R2 W( D. B
{//得到 cIndex 的数字索引: `3 ~1 U1 y, q, q
int nPos = -1;
* f/ z7 `* P% X6 q for(int i=0;i<m_nSize;i++){
2 X0 Y' Q3 S: @: D1 }6 O$ c if(strIndex == cIndex){
, j4 y: I3 `$ X: e% i: |& H nPos = i ;break;
6 r7 p7 c/ V9 f6 }1 b }
8 D' `: P4 g9 A }
" Q* a$ f' ^" r4 j6 V9 S; d# P return nPos;
/ P, D3 W& u* y' e$ z# X5 z1 Y! U}
6 B" |: T! {9 Xtemplate<class TYPE, class ARG_TYPE>
) o& ]7 x! [/ q% F. q ~' ^/ ZCString YCArray<TYPE, ARG_TYPE>::GetIndex(int nIndex)
5 Q8 e' N$ }( h! s{//返回 nIndex 的字符串索引, c7 R8 Z% J- y% _' E" a% n
return strIndex[nIndex];
; |# v9 l' a" g2 o/ p% l2 ~}
9 N) L: ~ z- k: X0 J9 T0 q. G/////////////////////////////////////////////////////////////////////////////
, v) P% ]1 Q) ]// YCArray<TYPE, ARG_TYPE> inline functions template<class TYPE, class ARG_TYPE>( k, u Y" S% h
AFX_INLINE int YCArray<TYPE, ARG_TYPE>::GetSize() const. p7 l# `$ d8 l" s4 N5 I+ Q
{ return m_nSize; }
9 o5 |8 A3 u9 s# R3 C- R; Xtemplate<class TYPE, class ARG_TYPE>- ~- e# _7 O0 I
AFX_INLINE int YCArray<TYPE, ARG_TYPE>::GetUpperBound() const
7 t+ L& \3 m! j6 b$ P { return m_nSize-1; }
. }9 u- q! L; P+ otemplate<class TYPE, class ARG_TYPE>
/ k: v( ?, H4 g" tAFX_INLINE void YCArray<TYPE, ARG_TYPE>::RemoveAll()4 k9 v0 O% | K6 W- {
{ SetSize(0, -1); }% H+ e7 ]/ X/ [8 M) v
template<class TYPE, class ARG_TYPE>
; w; i" b! v; d9 M* [& [AFX_INLINE TYPE YCArray<TYPE, ARG_TYPE>::GetAt(int nIndex) const
: r6 h2 @1 A5 b, C { ASSERT(nIndex >= 0 && nIndex < m_nSize);
. s* F; b& G& b' ]7 R8 b7 U return *Ym_pData[nIndex]; }; H& I0 H' w- u8 y7 l6 ~
template<class TYPE, class ARG_TYPE>1 m3 p8 K( c6 ]( B0 [# X( d# @
AFX_INLINE void YCArray<TYPE, ARG_TYPE>::SetAt(int nIndex, ARG_TYPE newElement)
% h& ^' f5 j1 k% W; W { ASSERT(nIndex >= 0 && nIndex < m_nSize);
" `) ~ A/ S3 n0 U+ Q$ g/ h *(Ym_pData[nIndex]) = newElement; } template<class TYPE, class ARG_TYPE>
+ J9 R1 B" i% E4 MAFX_INLINE TYPE& YCArray<TYPE, ARG_TYPE>::ElementAt(int nIndex)
* x; Q# X1 E' e( P* j$ y( Y { ASSERT(nIndex >= 0 && nIndex < m_nSize);4 k2 p: _& W6 u7 |
return *Ym_pData[nIndex]; } template<class TYPE, class ARG_TYPE>2 l8 F6 y5 ~) k) ?/ p0 ~
TYPE YCArray<TYPE, ARG_TYPE>::GetAt(CString cIndex) const' D e" m* {! @8 g
{/ r. d' f# O& z; Z
int nIndex=GetIndex(cIndex); L: j" `' q9 i
return GetAt(nIndex);
1 n9 U- p, l) o4 f' A: _' S}( E! |( W. D$ ^6 v x$ r+ S* u
template<class TYPE, class ARG_TYPE>
. n$ D) u" q, w6 I& p4 n1 wvoid YCArray<TYPE, ARG_TYPE>::SetAt(CString cIndex, ARG_TYPE newElement)
* s- W4 \% e) Z8 {, v3 r{
# L/ x* [: p" @' H int nIndex=GetIndex(cIndex);
0 Y# q2 _7 u0 h# ^1 D5 q5 c( _; Y) I return SetAt(nIndex, newElement);
8 a: C2 t' j4 U% n( K @}
( D P" ]6 H: m7 n! qtemplate<class TYPE, class ARG_TYPE>, @" J8 M! p ^( m
TYPE& YCArray<TYPE, ARG_TYPE>::ElementAt(CString cIndex)# ?9 _1 s5 L' u3 s
{
9 u, L- `3 @. e I int nIndex=GetIndex(cIndex);
5 d# X8 K5 J w, M return ElementAt(nIndex);. d4 z s* V% s& B4 y1 j" b
}0 V6 D: K; G) f, t2 X
template<class TYPE, class ARG_TYPE>$ r% i N6 I g; s! s
AFX_INLINE const TYPE** YCArray<TYPE, ARG_TYPE>::GetData() const
0 @1 w5 C) M3 k% |( Z7 L- E& [' C { return (const TYPE**)Ym_pData; }
) {( Q2 V3 x* D4 L8 itemplate<class TYPE, class ARG_TYPE># S Y% N' ^3 Y4 O/ P
AFX_INLINE TYPE** YCArray<TYPE, ARG_TYPE>::GetData(), {! e/ d P+ R& o
{ return (TYPE**)Ym_pData; }
9 ]5 b8 X0 u- M, c$ y6 Xtemplate<class TYPE, class ARG_TYPE>7 X2 d a3 u* J0 E6 ]% O) a
AFX_INLINE int YCArray<TYPE, ARG_TYPE>::Add(ARG_TYPE newElement,CString cIndex /* ="" */)
$ u% h$ S v) L/ y { int nIndex = m_nSize;: g5 e( }) r7 ?+ {
SetAtGrow(nIndex, newElement);
: N& y# z' n( f. T: B% K SETIndex(cIndex,nIndex);( t- F% M. `2 Z+ Z9 Y
return nIndex; }5 Q/ x8 R: M; e D( g% H8 h) f
template<class TYPE, class ARG_TYPE>& o" z$ E8 o- `' p' o( Q
AFX_INLINE TYPE YCArray<TYPE, ARG_TYPE>: perator[](int nIndex) const
# ], \6 Z! Q- Q k( X { return GetAt(nIndex); }5 `$ t# x( I* j0 i" f
template<class TYPE, class ARG_TYPE>' e9 F$ U" ?) {% D% I
AFX_INLINE TYPE& YCArray<TYPE, ARG_TYPE>:perator[](int nIndex)
( M: h9 s* e a! N9 T# v { return ElementAt(nIndex); }
! s3 n ^3 V. h) |9 itemplate<class TYPE, class ARG_TYPE>
, b+ E g' N! v$ ]: EAFX_INLINE TYPE YCArray<TYPE, ARG_TYPE>:perator[](CString cIndex) const
# z1 z5 o6 K) z7 ]9 Q! f8 ]4 N7 C$ u{) p' x3 P3 b h5 m7 | x! a
int nIndex=GetIndex(cIndex); return operator[](nIndex); |9 s& T9 `2 i4 D/ r ?
}! z M$ V* o, I
template<class TYPE, class ARG_TYPE>& P% A9 S V: J, ?" I
AFX_INLINE TYPE& YCArray<TYPE, ARG_TYPE>:perator[](CString cIndex)4 N/ E$ y/ I/ [: \, ~
{
+ I: H2 [6 u2 j) S/ F/ K m0 Q int nIndex=GetIndex(cIndex);
) ]9 x. R% N- z8 Q4 q% x' c return operator[](nIndex);
: H8 A4 t3 N& A& M* ]}% D) K( r$ Z( v7 d3 J
/*
: A g/ h1 U1 Etemplate<class TYPE, class ARG_TYPE>
, a( t; v* R/ O# f+ Y G/ b( oAFX_INLINE YCArray<TYPE,ARG_TYPE> YCArray<TYPE, ARG_TYPE>:perator=(YCArray<TYPE,ARG_TYPE>& tparr) const+ p% P g+ {! `* k% a
{
0 a! B, l4 n9 w' n+ i% [ E int i,j;6 w' K+ C9 W& k+ V. `- c, _ [
for(i=0;i<tparr.GetSize();i++){* \9 k- S: Q- z1 ~% \' K0 p
j = GetIndex(tparr.GetIndex(i));, N" @( X3 d3 N6 Z- x+ G% i& y7 f
if(j>-1){1 _- d6 Y3 j( v1 ]4 Q7 M8 D3 T
operator[](tparr.GetIndex(i)) = tparr;
) f+ |' `7 f d$ v }else{
- I: i! c( j( F0 K. k/ B* C Add(tparr,tparr.GetIndex(i));+ J y% M; v2 q" M0 W1 K
}9 T" Z* C+ B+ [9 C/ b. }
}
9 V6 |% d% h+ y return this;0 j D& W; [9 W& C: r
}
- x% l# m% e$ k8 N4 t% \7 a*/
9 T1 }" J/ P$ F) U. E; Ttemplate<class TYPE, class ARG_TYPE>
0 t3 O: k' Y l# K4 a7 RAFX_INLINE YCArray<TYPE,ARG_TYPE>& YCArray<TYPE, ARG_TYPE>:perator=(YCArray<TYPE,ARG_TYPE>& src)
r4 z6 j3 t8 `, [" w' ^{5 R0 c7 |/ u3 o# N+ \% f3 y4 ^# B
ASSERT_VALID(this);5 y5 m$ N6 l" K9 K! G9 s i7 [
ASSERT(this != &src); // cannot append to itself SetSize(src.m_nSize);: Z* C! b0 i- _6 p6 t% [
for(int i=0;i<m_nSize;i++){
: f- V( x+ Y7 t' L) m0 m- v /*将此句修改为内存拷贝*///
+ o* U1 u' _! r+ Z. I3 } *Ym_pData = *src.Ym_pData ;/ B& r! l! }! f! d
//memcpy(Ym_pData,src.Ym_pData,sizeof(TYPE));' J, y- o& n/ ]$ x! p8 {9 C
SETIndex(src.GetIndex(i),i);
+ `) y% o, ~/ z# C- z& H }7 l7 E$ [" J% i2 ?
return *this;
9 z$ c% e+ G% k H+ f0 l& K( J}
. U8 V9 |2 o5 F7 K2 F n; M/////////////////////////////////////////////////////////////////////////////0 W8 L; X+ U) a! s' V9 i9 P1 a
// YCArray<TYPE, ARG_TYPE> out-of-line functions template<class TYPE, class ARG_TYPE>+ d1 k# w7 \' F( ~4 N7 R% _
YCArray<TYPE, ARG_TYPE>::YCArray()( R# R! H. `! F. s9 Q2 z+ w( B
{
4 F& Q3 l6 D( ~/ j ?' O: Y. x6 l' H Ym_pData = NULL;
: Y% _' V$ _ W7 Z$ T3 E: z# _: Q strIndexNum = m_nSize = m_nMaxSize = m_nGrowBy = 0;0 M" c' F* B: e+ w( A
strIndex=NULL;MAXSIGNTIME=10;
5 G; I6 F+ n& H2 S& L1 k- b3 w}! w5 n9 Z5 g" O8 f4 a! b
template<class TYPE, class ARG_TYPE>* p; @' j# i& {0 J/ V
YCArray<TYPE, ARG_TYPE>::YCArray(YCArray<TYPE, ARG_TYPE>& tp)0 O8 R) t+ l$ ^+ T
{
: N" V9 b$ L0 ^, u$ u b Ym_pData = NULL;5 F. D* v/ J5 P3 W h6 g9 f8 m2 X
strIndexNum = m_nSize = m_nMaxSize = m_nGrowBy = 0;/ ^* S/ q* a. _7 M6 s, x2 b
strIndex=NULL;MAXSIGNTIME=10;
8 R" N. T6 {- w' Q! x$ A6 W operator=(tp);5 h7 Y0 q; m1 _ q/ s1 E
} template<class TYPE, class ARG_TYPE>
6 c4 b4 d, m9 H, Q+ c" Mvoid YCArray<TYPE, ARG_TYPE>::SetSize(int nNewSize, int nGrowBy)* E+ l" Y' K% G( I
{# r Y$ ^; j; B. J
ASSERT_VALID(this);2 X+ m$ |! p0 V) `9 U
ASSERT(nNewSize >= 0); if (nGrowBy != -1)# k# S3 Y# n7 p2 d1 X+ o9 E
m_nGrowBy = nGrowBy; // set new size if (nNewSize == 0){% S' n2 A, k/ h4 Z- R0 l
// shrink to nothing
; k9 |. N- W; d, G d: A if (Ym_pData != NULL){
) e1 G6 S, {' ~ DestructAllElement(0,m_nSize);
, C- }* s7 t) T# I //DestructElements<TYPE>(Ym_pData, m_nSize);
3 i$ |9 R5 @/ l8 t) g; _) ? delete[] (BYTE*)Ym_pData;* D# a: W! M3 z4 ?; ?. I2 v% l
Ym_pData = NULL;
- S- \1 o( L- t- } }
2 E: ? ~& s1 m m_nSize = m_nMaxSize = 0; z+ Q, I& m% R: A" x% O% q
} else if (Ym_pData == NULL){! |$ h# @5 W' O* }* w2 Q( W8 |
// create one with exact size
j- E- L- z( I0 ^#ifdef SIZE_T_MAX3 X/ U* `. ~0 F" ?4 F' J3 D0 s
ASSERT(nNewSize <= SIZE_T_MAX/sizeof(TYPE*)); // no overflow
: [9 v) D" p7 P9 ]#endif
! g) B: q, E% c# R, y/ B9 p5 X Ym_pData = (TYPE**) new BYTE[nNewSize * sizeof(TYPE*)];& A7 w8 |( W( K. ?7 k/ e. C
ConstructAllElements(0,nNewSize);//ConstructElements<TYPE>(Ym_pData, nNewSize);
, W- y3 p& _: K. K7 f/ w m_nSize = m_nMaxSize = nNewSize;+ t% ^. X: A" I9 E
} else if (nNewSize <= m_nMaxSize){- v% O3 X0 v& y, x% Q, A+ v2 ?
// it fits
- F% C% N- ?: {3 Q' S if (nNewSize > m_nSize)* P8 T3 N; p% H) `2 t6 t" p
{" j! h9 j5 q% m) C. m
// initialize the new elements
, c; s W' @( Z' L7 Q ConstructAllElements(m_nSize,nNewSize-m_nSize);//ConstructElements<TYPE>(&Ym_pData[m_nSize], nNewSize-m_nSize);
$ l4 \$ K+ G. K }
4 u& v: @- p1 f# D/ ]; e( Z1 D+ _ else if (m_nSize > nNewSize): x4 B: t3 C& h# W
{8 @, s; L( Z; V1 S |) y) K+ N
// destroy the old elements" ]5 M' ~4 l& D! Q& u3 ?% s
DestructAllElement(nNewSize,m_nSize-nNewSize);" j0 N+ _- y" P+ E, V! v
//DestructElements<TYPE>(&Ym_pData[nNewSize], m_nSize-nNewSize);& Y' C+ t8 v) l
}
- r; S5 X: Y/ U' N m_nSize = nNewSize;
0 p% v$ Y+ y& T+ q9 i) _6 k }* n* _$ k$ A9 u3 L/ n
else3 ]* I. \: b5 a% P$ m. X
{ ^( A) H) }8 @& q! o& k
// otherwise, grow array
F: E5 t' u/ n int nGrowBy = m_nGrowBy;
9 O* d9 X' @1 g8 Y! L if (nGrowBy == 0), M# V- N/ b( ^' a; y. i" ~
{
1 m' O. k6 [2 G& ^+ t4 R6 s // heuristically determine growth when nGrowBy == 01 ~: O( M# G. L8 d& l$ t7 r
// (this avoids heap fragmentation in many situations)# c: Q: o: K% ^! h
nGrowBy = m_nSize / 8;8 s+ R; g" {3 h
nGrowBy = (nGrowBy < 4) ? 4 : ((nGrowBy > 1024) ? 1024 : nGrowBy);
$ g$ R( s& r+ _ X/ L5 u1 Z }
$ H# b( G& e5 n4 T* w! k int nNewMax;8 Y' Y1 `& m/ D1 {; N
if (nNewSize < m_nMaxSize + nGrowBy)! G; p; w% d/ E: N
nNewMax = m_nMaxSize + nGrowBy; // granularity; @; ^% y6 Q/ q
else9 v5 U3 S5 y) y: ]* T
nNewMax = nNewSize; // no slush ASSERT(nNewMax >= m_nMaxSize); // no wrap around( E# U5 i% I4 Q- N2 i' T! G
#ifdef SIZE_T_MAX
" x( F% ]5 v2 m ASSERT(nNewMax <= SIZE_T_MAX/sizeof(TYPE)); // no overflow
- q# N; Q5 \% J#endif1 p4 H8 X8 Z+ F/ f
TYPE** pNewData = (TYPE**) new BYTE[nNewMax * sizeof(TYPE*)];//TYPE* pNewData = (TYPE*) new BYTE[nNewMax * sizeof(TYPE)]; // copy new data from old
0 v. y% T2 e# {, \; T6 K$ |# l" x memcpy(pNewData, Ym_pData, m_nSize * sizeof(TYPE*)); // construct remaining elements
4 a0 o! O! W4 J9 b1 ]2 u: t ASSERT(nNewSize > m_nSize); //throw("/*wait for me --- yzhlinux*/");% ^- U6 D% o2 N' N- C4 E1 Z9 b
delete[] (BYTE*)Ym_pData;
" d1 ^ `$ _/ n7 Q6 }' S( v Ym_pData = pNewData;
6 V1 X& M9 C& Y8 R ConstructAllElements(m_nSize,nNewSize-m_nSize);//ConstructElements<TYPE>(&pNewData[m_nSize], nNewSize-m_nSize); // get rid of old stuff (note: no destructors called)
( u0 h* z2 H' r$ \" s m_nSize = nNewSize;! q( k& g; b3 U+ \7 ]5 |+ R
m_nMaxSize = nNewMax;" ^+ F0 l8 e; Z, U! p
}6 W+ x4 x# O9 B6 p; Y9 A$ @
SetIndexSize(nNewSize);: f7 i8 a: U6 @1 t. H0 j8 N
}" Q8 _0 i& n x o1 Y( @8 o
|
/1 
IP卡
狗仔卡
发表于 2005-1-10 13:45:00
QQ好友和群
QQ空间
腾讯微博
腾讯朋友
收藏
分享
顶
踩
转发到微博
提升卡
置顶卡
沉默卡
喧嚣卡
变色卡
抢沙发
千斤顶
显身卡
楼主
发表于 2005-6-3 17:55:00