TTypedList一个类型安全的TList模板类

韩冰

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

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

4 a3 g- d9 f% B; t: I

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

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

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

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

#include <classes.hpp>

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

* @- `2 C6 q* [4 z

template <class T>

class TTypedList : public TList

{

* D+ P+ O% X6 o ]9 @6 P

typedef TList inherited;

3 \( a4 J5 p8 N7 l

private:

bool FAutoClear;

TClass FItemClassType;

' I/ k: X1 m" d3 ?3 a% `

protected:

f3 L5 q6 Q0 B7 B6 K' U+ Z. t7 }

T* __fastcall Get(int Index) const

% y1 e; [. |/ O; Q. }1 [- h* o, A

{

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

* R" _- G# F6 Y, j$ }

}

void __fastcall Put(int Index, T* Item)

{

* d0 ^/ r' P% {' E, L

inherited:ut(Index, Item);

}

5 U# y2 V |% E, M' j& q2 p1 W7 R

public:

0 Q8 w" N6 E0 M1 D# {3 V

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

public:

0 A& V1 f& e0 B; u$ ]

__fastcall TTypedList(bool bAutoClear = true)

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

$ P3 l% ?0 I7 Y4 ]6 Q: K- M

{ }

! K9 G! k5 K, ?) c

// no destructor needed

+ }2 O3 O$ k$ f: `4 y* m' d

int __fastcall Add(T* Item)

{

7 T! q/ l$ ~' v* C6 `* ^6 }% T

return inherited::Add(Item);

! K( q( G& J- y# f! D

}

int __fastcall AddList(const TTypedList& List)

, K' R- l( `7 _. }! \

{

if(this == &List)

+ `5 j) \+ S. _) G) E

{

/ J* r( s6 |9 S# o4 I

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

}

. ^0 N) ~. c% U9 X( X

if(FItemClassType != List.FItemClassType)

9 @( R% b, R, F \7 p, v: `

{

+ H5 I* B* R8 ^6 f8 H

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

Type!");

8 |# {. v% ^- R% k

}

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

/ J m) j5 `0 D6 ^( H$ v. B

{

& k. g1 @3 \. a9 P3 l4 s

Add(List.Get(i));

}

return List.Count;

% M c# ]0 p1 T! ^; E; s4 K

}

virtual void __fastcall Clear(void)

& J: g. U- D4 W0 w2 C+ J3 b( R6 Y2 b

{

if(FAutoClear)

4 A+ _8 H# z9 J: f9 _8 q

{

7 B% m' {2 [5 S* B

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

! p. {+ V; ^4 l$ n, N. \

{

delete Get(i);

. q K4 q% S' b6 K) g6 b* k

}

}

9 J. [3 ?# t3 f R

inherited::Clear();

x& G3 @$ u. h

}

* b# C; J/ ~$ l+ L$ C/ m* V/ S- Z! f) {

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

{

if(bAutoDelete)

3 `1 u( v' Q- b4 M0 o( _

{

% T2 u( J& E) S* k8 c

delete Get(Index);

}

# F" p$ L" A) L( T

inherited:elete(Index);

}

: ]& u. B% L8 Q |0 \/ a

T* __fastcall First(void) const

{

% B! U6 c4 a4 i" U1 d

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

}

) O1 W* S& w! L0 f" g

int __fastcall IndexOf(T* Item) const

; u/ @. H% H. y) G

{

" D' y. b) ^* F9 L B7 e5 y3 k8 A

return inherited::IndexOf(Item);

* K# }, X& f2 e+ Z: K

}

6 i) X5 Q6 d: {7 s+ V. o/ `1 g

void __fastcall Insert(int Index, T* Item)

9 j- l# x" U2 q4 W6 `$ }

{

) a9 a4 ~' @, w* z

inherited::Insert(Index, Item);

# c0 @$ v- q/ _* l$ }2 G# o+ T, v

}

% K9 R: g- E3 Y) p% F+ m

bool __fastcall IsEmpty(void) const

{

return Count == 0;

4 K8 F; n' R2 f) a o

}

T* __fastcall Last(void) const

, B2 {8 _/ U$ J, b

{

- \- z- h) n1 h5 t3 W

return (T*)inherited:ast();

( V+ m0 C: x! K6 ~3 y: r7 \# I3 l

}

& b% K# e$ y$ N

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

! f; R9 `* o3 i1 a6 q# w! e& b6 V

{

int nIndex = inherited::Remove(Item);

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

{

delete Item;

. V6 v, E# |6 W9 J1 l

}

return nIndex;

0 a" i+ ?- c& p9 D' b7 c5 l, F$ P

}

. r& s! o5 K) v5 [/ _. K, ~8 a) T

void operator<<(T* Item)

{

! A7 n$ L# y. F2 z

Add((T *)Item);

}

, y5 W8 F- x' C

void operator<<(const TTypedList& List)

- g' S+ H0 A# Y2 {2 A$ P1 B( C' E

{

AddList(List);

) d( p7 W6 t8 N$ P9 B: ?

}

}; // end of TTypedList

8 D V+ U" ~" P C3 O! W

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

#endif