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

韩冰

K! i" i9 K( ]" U, G& f

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

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

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

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

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

% @( F' T B" ~; m3 F/ B' d

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

* q- {7 N- x- E! W) G+ U0 D

#include <classes.hpp>

2 n9 X$ z: g( A# Y- w

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

template <class T>

class TTypedList : public TList

{

typedef TList inherited;

0 g; L b8 w+ T2 I; A

private:

4 `* @* @) b) \0 s5 p+ \* D, O

bool FAutoClear;

0 ]/ s) J+ M8 g) I/ D7 Q$ F

TClass FItemClassType;

protected:

T* __fastcall Get(int Index) const

{

4 a/ s) a' n5 S& _; N% u

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

}

+ Q8 H; e; _; o G, ^

void __fastcall Put(int Index, T* Item)

0 q; P9 d3 R5 |: K

{

, A; a5 A9 P: l" y" }

inherited:ut(Index, Item);

}

public:

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

3 P2 a) l% L5 \! T

public:

; ^; [( |4 k" q; a2 U) A1 f

__fastcall TTypedList(bool bAutoClear = true)

3 d- t7 B: R4 |/ O- ]3 @. K/ K

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

{ }

// no destructor needed

1 S; m( x2 u1 h. H: _+ y0 m

int __fastcall Add(T* Item)

$ m1 [2 Z d1 |

{

/ P: E& O' p9 R

return inherited::Add(Item);

: E8 O- h) }- O' I# u8 F. `! P

}

" h( p- d3 ?! J; I9 V' g, a& p

int __fastcall AddList(const TTypedList& List)

4 S4 y, B4 a L: v* s6 k

{

if(this == &List)

! h+ d5 |! H, E" s" T" d1 t

{

" T! I% r7 i3 Y& X/ M4 U) h

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

/ ] G* a6 a$ k* ~8 u+ f

}

2 g# q* [3 }% L

if(FItemClassType != List.FItemClassType)

{

6 g% g, i) K" O, P2 y

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

Type!");

' p* }$ q0 A7 n0 H0 v

}

0 J1 Y; [0 J& U9 R, c+ { ^$ ~* {

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

$ [' ^$ ]; L- z9 F$ T5 K% W9 ^9 t1 y

{

8 j* g! a( N! k9 U

Add(List.Get(i));

: i" q& F0 P3 c" I; X, @7 p/ Q! C

}

return List.Count;

- t! f8 A6 {' x' c* `

}

virtual void __fastcall Clear(void)

3 q6 e4 y3 T2 Z: Z

{

+ e& `) y: [: t

if(FAutoClear)

- P7 \" ]% H7 U) N1 b9 M/ @$ [* U

{

+ m i9 X/ D4 V

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

( G5 T$ g0 S6 N9 C2 A% |0 k/ A

{

9 X6 m+ k i" s/ V

delete Get(i);

}

}

inherited::Clear();

. F& S8 m! Q* Y( J

}

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

8 @7 c0 Q( k' y3 j

{

9 a' z7 C3 T5 v1 P4 }

if(bAutoDelete)

6 D/ G8 ]9 y$ r* X

{

delete Get(Index);

9 R$ B3 k& v$ o$ q7 H

}

inherited:elete(Index);

0 ?- r P9 }7 ~

}

7 ]3 o" Z/ g5 A/ h

T* __fastcall First(void) const

- S5 `& U$ l. K5 o6 w) S5 A4 v" F

{

! p! l1 F! ^' @' L

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

0 z/ R* l. J, G! w# `; N

}

6 o5 k8 I5 ^, r/ X& g- ^/ B, q

int __fastcall IndexOf(T* Item) const

{

1 q! t& j0 y0 w9 h w

return inherited::IndexOf(Item);

}

- `6 M& f0 x) Q

void __fastcall Insert(int Index, T* Item)

8 S, p& ^( @: \7 f5 i `0 R/ f7 I

{

inherited::Insert(Index, Item);

}

& S5 S7 k. R3 C1 T. d; j

bool __fastcall IsEmpty(void) const

{

+ m2 [8 l( U! S8 A

return Count == 0;

}

8 U& Q8 H" B: U: m1 \ h

T* __fastcall Last(void) const

{

1 Y2 m! l6 d$ f& f- m

return (T*)inherited:ast();

; ^( q- l; @! ]

}

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

{

5 Z6 F6 i+ B( o+ N

int nIndex = inherited::Remove(Item);

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

/ A# p$ r0 N% ?0 I H; J

{

w; W! H% |$ B9 s8 A0 z$ k l

delete Item;

* j% t* k: B; @, G# p# C! L8 _

}

return nIndex;

}

% _, I: _/ R) [! |' Y& ~

void operator<<(T* Item)

{

" z* F) c: x% c! K3 I% {6 [+ |3 a

Add((T *)Item);

) G- w6 e! {& Z% _3 i

}

( B& X5 ]2 T) K* g1 L. t

void operator<<(const TTypedList& List)

+ g7 H" `: k! U j E3 |% y0 `

{

AddList(List);

6 F5 ]8 q' g7 y

}

}; // end of TTypedList

/ l5 x1 E8 y) z, N$ h

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

+ L% @$ f* ~1 f

#endif