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

韩冰

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

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

+ Y3 Y+ W1 B0 N& ~* w) a' ^

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

" ?# ?- O: {6 }! T

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

: d9 y9 p& y) f# S% ]; V" i9 y- b

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

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

#include <classes.hpp>

% ^, Z4 V2 A: @9 W( }+ x

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

; D0 n/ u N( h: _2 y+ M& U

template <class T>

class TTypedList : public TList

{

typedef TList inherited;

) h) k5 _7 c& \& U& t% X

private:

bool FAutoClear;

! v: \. `5 g& R/ K& M5 A1 Q) V

TClass FItemClassType;

8 k( C" p. H' F7 I) J7 y

protected:

- [" [5 Y J4 ^: N

T* __fastcall Get(int Index) const

{

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

}

' v& T) ~( |/ G# \

void __fastcall Put(int Index, T* Item)

{

inherited:ut(Index, Item);

& H- H" y8 F% c2 K0 v

}

& G& t# o6 m6 Y8 _- Z

public:

1 ^: N8 z! f9 s+ ?

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

public:

0 ~" c; y1 d2 X& J8 [5 s# e7 a

__fastcall TTypedList(bool bAutoClear = true)

. v" D+ R' D/ _& x* q6 N% ^. y

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

{ }

) \- i( }8 g. o: ?( v

// no destructor needed

6 t6 T' \$ b- C7 C D+ F

int __fastcall Add(T* Item)

{

$ K7 e" y$ S$ K6 e; `0 z

return inherited::Add(Item);

}

int __fastcall AddList(const TTypedList& List)

# I& l8 `/ h" K/ }2 C1 C

{

if(this == &List)

B5 n0 A) o: s

{

7 z2 [# T( k* d/ n) E# i" A4 E

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

}

if(FItemClassType != List.FItemClassType)

{

P0 r- p! @' M/ O: h: T0 j: f

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

" [, n! d7 Z5 A0 Z

Type!");

9 ^3 J$ _ A" h3 O. V" j5 \

}

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

{

Add(List.Get(i));

}

% ?$ R3 Q2 l: R: W

return List.Count;

}

virtual void __fastcall Clear(void)

( @2 @# g& H0 U$ C# j" k: E

{

; m5 `( ^4 h" c Y

if(FAutoClear)

7 O/ o, ]9 ~" e! g# o) I2 f: G

{

, y! x- {. }) A) s* ~

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

2 {# H' s/ Y1 m3 u

{

$ K7 w0 z- E" a U B* y1 y

delete Get(i);

8 A3 x Y* b7 D# I. j

}

% W4 `& o; E, e" d

}

inherited::Clear();

}

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

{

T5 l% T1 o+ y

if(bAutoDelete)

+ F) f6 }# @. B/ B8 E* D7 |

{

# x( a; w% B- R& d% f- f+ D

delete Get(Index);

}

( _5 [! x" h) U1 f

inherited:elete(Index);

}

7 Q }7 w& ~+ t* {: ?$ x V! p

T* __fastcall First(void) const

8 \9 ^% R, Q9 Y5 H) U) Q* Z

{

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

}

int __fastcall IndexOf(T* Item) const

{

% g1 `& `5 T5 G x: y

return inherited::IndexOf(Item);

}

void __fastcall Insert(int Index, T* Item)

, M8 m' D" q. _( X3 `

{

, _* j4 b/ A9 M* q/ N/ Z: q

inherited::Insert(Index, Item);

5 l5 c2 o' c W* W$ V

}

bool __fastcall IsEmpty(void) const

{

- S5 b6 _+ r B0 O* v

return Count == 0;

: U3 Q" I! m7 G! f9 J9 h+ `

}

$ _) b. d) N6 c/ e6 F

T* __fastcall Last(void) const

+ n K5 a' ~0 K5 C+ P

{

return (T*)inherited:ast();

! S) _2 |; y" G/ X: _; c; t

}

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

& G$ x$ J- |; Z' I& R

{

, X* R1 L" N& _- s5 C. a

int nIndex = inherited::Remove(Item);

. o& j6 o0 x; L: I3 T

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

{

" O8 ]; m* l3 D Z+ Z# o; ?% m5 e

delete Item;

}

return nIndex;

3 l5 D) }2 c4 @! x

}

void operator<<(T* Item)

' D# Q+ [( q7 d. }6 Q: X6 m

{

* y+ n2 n$ n% m& ~- m7 T

Add((T *)Item);

, W0 s; w! ?6 b3 O: X* K3 X- H

}

void operator<<(const TTypedList& List)

( `" |# ?- d$ O* N

{

2 s# x( N0 f: Z( u2 d9 c

AddList(List);

}

8 Q+ f6 h' z# ^, f2 A7 ]2 V

}; // end of TTypedList

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

#endif