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

韩冰

4 P2 r% T' j+ ^4 z& r6 o2 k

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

4 P% I0 h* K- N

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

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

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

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

% k6 b5 E. M* }% S8 P0 X) {

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

1 o/ g# n0 w+ k- O4 c* s) c

#include <classes.hpp>

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

; c* n$ `. z" u0 T

template <class T>

9 ^/ m, W* c4 u f% E. _" b

class TTypedList : public TList

{

typedef TList inherited;

private:

bool FAutoClear;

* U' j/ x q- C) I

TClass FItemClassType;

( p7 j" A3 r9 s5 n8 ]6 ~- I

protected:

T* __fastcall Get(int Index) const

{

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

. O6 Q8 w5 ~9 ~9 |# ?

}

void __fastcall Put(int Index, T* Item)

{

# ~% A2 I# C* X$ v$ C! h

inherited:ut(Index, Item);

}

public:

" y9 a: b9 D/ {% D% K# A y

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

9 K" w/ O# [* G l% @

public:

( J2 I& g% j- j' F$ Z) Y

__fastcall TTypedList(bool bAutoClear = true)

- v! q# \' D2 k

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

3 J0 C2 M1 ?; C: U `5 ^8 k

{ }

// no destructor needed

int __fastcall Add(T* Item)

! d' ]* Z- P! E

{

- R6 ^8 ^; K& _

return inherited::Add(Item);

}

int __fastcall AddList(const TTypedList& List)

{

3 a( ^+ n8 c8 Y/ F1 o9 H% q

if(this == &List)

' W7 j; o. _8 [0 C, g5 [, n. {

{

; w, N. d9 x! {5 `" {

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

% E% }5 @ \0 B0 d1 b! P, m! v

}

if(FItemClassType != List.FItemClassType)

" F, c1 D# t: ^3 a; A. v

{

4 j }# W1 w- O; ?7 r

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

$ Y% }4 | O {+ L. Y Z* p! I2 }- E

Type!");

}

7 Q5 D ?# w3 X/ R

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

{

- r+ ~6 K' I4 L! _' |8 N' w

Add(List.Get(i));

}

% `) Q* w1 G: q4 z' W

return List.Count;

}

virtual void __fastcall Clear(void)

{

if(FAutoClear)

{

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

$ F( u# F. Z h1 `6 P! e- `2 [

{

f- h4 k( F' _$ ~$ \+ A

delete Get(i);

}

}

inherited::Clear();

}

5 T3 z; ~$ p' A ?' d

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

{

$ ]5 S# E% ?2 \9 S

if(bAutoDelete)

{

delete Get(Index);

}

' k4 b1 t" J/ j! M5 l

inherited:elete(Index);

}

T* __fastcall First(void) const

1 H% E: ^- M& Y. O! k& f

{

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

& `$ B( d1 N Z' ~) t

}

* g# H% M R) W+ O4 P

int __fastcall IndexOf(T* Item) const

{

2 d* [( T* K; g) `& X2 R$ R. Y: _: c7 i" o

return inherited::IndexOf(Item);

z7 o% s8 r4 n

}

z6 Z n/ t9 ~7 o9 x$ C& W, J

void __fastcall Insert(int Index, T* Item)

: g8 X3 ?( P7 ]8 c% b. \3 ]

{

inherited::Insert(Index, Item);

8 V' L: y; E0 o# i& _5 M

}

bool __fastcall IsEmpty(void) const

5 R: K9 n; v+ J' \: R) C

{

return Count == 0;

9 A h1 f9 m }7 ?8 B8 ^6 `; {3 B

}

T* __fastcall Last(void) const

{

return (T*)inherited:ast();

! u8 q+ a1 C; s! _& K+ {, P

}

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

s5 C: X( N4 m( k

{

int nIndex = inherited::Remove(Item);

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

9 u2 N" x2 V. N' Z# ~/ }

{

delete Item;

: Y9 V+ i( S3 ~

}

# }# C1 f F5 Y& f) L$ d

return nIndex;

Y+ y/ A. S( Z4 z4 X

}

void operator<<(T* Item)

{

: I- ^/ D1 m3 o( ^

Add((T *)Item);

}

; x S5 y% S, I( k7 w" N! g* z

void operator<<(const TTypedList& List)

' i9 q9 S; y4 O/ d; @% s

{

( o$ I1 s1 z7 {5 ]% B0 T' p1 I

AddList(List);

, \4 U$ w( v. B6 k

}

/ K9 N# j5 e6 q q* [* N

}; // end of TTypedList

3 d0 z8 H% H5 r2 A& O: e

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

#endif