数学建模社区-数学中国

标题: TTypedList一个类型安全的TList模板类 [打印本页]

作者: 韩冰    时间: 2005-1-26 01:11
标题: TTypedList一个类型安全的TList模板类

( `8 ?! f1 o, j6 j. L* h" ?

偶在一个老外的文章的基础上写的,应该很有用的说,

: h/ E# P# W) X# h% E. Q' S

以前总是用STL的vector做替代,但是STL的用法实在不是很习惯

; r( h5 J/ f( s4 G# w- g

) w0 J) U/ W4 {+ H9 c# g* x0 a

//-------------------------------------------------------------------------

6 ?' h7 A* A3 P

#ifndef TypedListH_0CBFE2E8-E7C5-4D88-9844-1F177F4B00E4

5 \" g* q5 \6 n: @+ U

#define TypedListH_0CBFE2E8-E7C5-4D88-9844-1F177F4B00E4

) H- y6 X) a: M3 }: ]# v0 o; W

//-------------------------------------------------------------------------

0 [9 w; H9 }/ \- C3 }& |

#include <classes.hpp>

6 g) _/ C' P4 H( U9 [7 M

//-------------------------------------------------------------------------

2 x% L- K v# a+ Y

template <class T>

* m8 j' ~0 o/ x3 U4 t! M

class TTypedList : public TList

) \6 {$ p" y2 C% u3 O5 v/ u* {! p

{

; x, U, h9 d7 O; o& w

typedef TList inherited;

+ z, x# Y9 J8 c* y0 t y

private:

% n0 ^9 K- V$ S" v

bool FAutoClear;

( D6 u4 f# R2 w5 p6 T1 W

TClass FItemClassType;

* Q( O: ]# T0 e9 r5 ^# _

protected:

$ u3 `' D4 W& M3 F

T* __fastcall Get(int Index) const

" u# o( g' f' W. w! w* l! z

{

! s/ Z' e2 o) h

return (T*)inherited::Get(Index);

: t# C3 \! l6 j! v* U: V# D1 }

}

8 M1 s' z {2 m7 a& @

void __fastcall Put(int Index, T* Item)

5 E0 O4 A, E& x9 C0 b) Q

{

3 B3 E" }7 L2 S, b

inherited:ut(Index, Item);

; S2 D& T" k) F, M7 N. V6 g" V. i8 w

}

) n6 V1 d2 V. E5 @# q, C

public:

6 q2 K" c; K' U/ u

__property T* Items[int Index] = {read=Get, write=Put};

) R! U0 e5 p# Q& Y

public:

4 Y3 Y$ r& f5 N* u5 \7 _! {& u

__fastcall TTypedList(bool bAutoClear = true)

& d4 J3 f2 R5 t" v/ |( @9 L/ R" B/ `/ }

: TList(), FAutoClear(bAutoClear), FItemClassType(__classid(T))

' I6 y! K+ g+ n

{ }

0 ?& l. z4 t$ ]3 |

// no destructor needed

0 y N3 ]( P m" t/ R% W; C. T

int __fastcall Add(T* Item)

% M% H# k( n5 ?1 E( ~

{

0 h1 k# g* A; u) w

return inherited::Add(Item);

, a6 j6 G& R: Z8 N

}

8 q. N4 D4 v l6 S3 v

int __fastcall AddList(const TTypedList& List)

1 r- x5 D+ f: I- P- q# O

{

% }, V- _5 P, S+ Y' K5 {

if(this == &List)

1 Z/ f& k3 R2 \, p, p7 X

{

3 l: R o% Z1 R+ H0 ~

throw EInvalidPointer("Can't add a TTypedList to himself!");

1 V4 I/ K0 G3 q+ i3 ?% L. p9 L: V

}

0 R$ W- ?& F7 E( z% K2 G, T

if(FItemClassType != List.FItemClassType)

- R( c4 Z2 n. c

{

" p. _* }; M# E, t( r% f/ [& l6 J

throw EConvertError("Can't add a TTypedList with a different ItemClass

+ w- t0 I0 c1 O3 a5 O+ a

Type!");

, N! r) g4 C1 ?- s% b. _. f

}

# k5 c. J) `" q

for(int i=0; i<List.Count; i++)

: v; c2 i# k1 _

{

! y& m, U4 y% D2 R" _

Add(List.Get(i));

/ Q _, N. v% R7 t, \' f

}

' b) l" x u1 F1 Z: m

return List.Count;

- @! {# G* U% G. ^3 w" u

}

$ N9 ~5 }0 m# b

virtual void __fastcall Clear(void)

3 _ ?, a# G% }; u% S2 O/ p

{

3 z E3 X8 c; v4 r

if(FAutoClear)

2 Z0 W m$ i+ e9 _* Z! ?8 E

{

, P" a& W$ Z7 U- a7 ~9 o

for(int i=0; i<Count; i++)

2 h' b* l8 m: b& w9 v- n

{

' h' S% V$ q# ~( q) ^3 v% f! Y

delete Get(i);

* z' x7 U8 c3 s$ @6 J

}

1 p0 @' O" c @7 I. r

}

0 l$ o) e/ r& Z6 K: }; g& W

inherited::Clear();

9 m; F2 F, \6 ^3 t6 n4 E

}

4 Z9 x, z- G2 J; N6 h/ ]1 R

void __fastcall Delete(int Index, bool bAutoDelete = true)

* }! F" }9 _: B+ c

{

6 `6 [4 H$ ~7 W) X" N8 \) F# H

if(bAutoDelete)

6 b7 ~7 X" W+ c/ Q8 i& K$ b

{

- a( U+ C: C' Y

delete Get(Index);

$ }# T5 D3 U6 E4 H

}

+ {+ g& E. B! @1 J

inherited:elete(Index);

, v0 C, Q$ e9 N0 r+ r1 g$ s

}

' V" Q3 L9 V- K% w7 E3 n( h

T* __fastcall First(void) const

1 k# Q4 `5 t& ]% m Z

{

; W+ `; B' ~$ x6 z D

return (T*)inherited::First();

" o( q: ^# |. c! [- k" g0 M" c

}

* V8 a! i5 J- I

int __fastcall IndexOf(T* Item) const

+ U& o4 |! E0 ]* S, C" j

{

* K: |8 H* N. s: L* \+ _

return inherited::IndexOf(Item);

4 Q9 M# W, P5 B0 s

}

: c/ q, T" P/ q4 R' ?. L/ g; E/ W2 n

void __fastcall Insert(int Index, T* Item)

" B a- _9 ?$ v$ g- o* D8 o/ C! z

{

" e* V0 t1 I/ m2 m

inherited::Insert(Index, Item);

, ] O+ `3 k* E9 b

}

. q( n* p3 ]* q% f/ n

bool __fastcall IsEmpty(void) const

8 G3 ? g7 S m7 q: Q2 P

{

3 q+ p( A) d) K7 }! x

return Count == 0;

1 t5 e4 \8 j& j/ [

}

" s: r6 V4 F+ O2 M& @

T* __fastcall Last(void) const

& |- ~1 i4 R9 \; k3 v: c

{

+ Q& q/ ?) u" `" g7 K" Q; u$ Z

return (T*)inherited:ast();

. V0 @9 b" _: e) @$ h

}

0 M. H+ q; ~9 {6 ]- [

int __fastcall Remove(T* Item, bool bAutoDelete = true)

9 ~/ \% F% @+ o2 P7 g

{

k8 |3 T P. q. \5 D: ^) z

int nIndex = inherited::Remove(Item);

' M a$ P! K$ b, n) p; ^! C

if(bAutoDelete && (nIndex != -1))

: H$ ]$ y, o/ ?3 O

{

) Q: m+ v; f4 D4 C5 G+ {- I6 S

delete Item;

; X8 Q0 C) j3 n% k+ t; w( A; k

}

}2 e7 F3 d. t

return nIndex;

; {: ^# @/ m! h/ h

}

# ~( Y1 ~; s% S% Q

void operator<<(T* Item)

( P& ^3 M+ `* u" q8 r5 a' L

{

- G, w% i2 j, Y- c" V# G& j$ C3 b

Add((T *)Item);

. l% a: H5 C9 f# N* m9 b4 w$ }

}

; T: X5 V0 g8 w6 V* l1 Y

void operator<<(const TTypedList& List)

0 Z! c9 _* t) W% p0 n+ O# F( ^# T7 \: t

{

$ M/ c: z0 L+ [+ g W

AddList(List);

% w& H0 }6 ~7 k* r5 p- [& F

}

4 ~2 A" K9 M# M* y- y

}; // end of TTypedList

7 D$ T9 m) {% E- ?* v

//-------------------------------------------------------------------------

" k' s8 H' S6 v1 T: H! w6 y. d

#endif






欢迎光临 数学建模社区-数学中国 (http://www.madio.net/) Powered by Discuz! X2.5