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

韩冰

2 x" q; o. }+ v8 m6 d, H. v

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

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

4 g: j1 h8 U0 X8 @( d( A

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

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

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

5 H, y% ^- R' U8 K

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

#include <classes.hpp>

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

template <class T>

class TTypedList : public TList

) P; n7 Y* J% K. X3 z& }

{

typedef TList inherited;

private:

bool FAutoClear;

TClass FItemClassType;

I1 m, L- o- @

protected:

) h0 G2 U2 M2 b

T* __fastcall Get(int Index) const

! M9 M- y. y: y; k2 }

{

2 ~- t6 M0 k. r6 ?7 @. R

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

8 k0 V" [9 [2 Q( R

}

void __fastcall Put(int Index, T* Item)

{

inherited:ut(Index, Item);

5 M& ~$ e1 h* s; j F

}

public:

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

public:

__fastcall TTypedList(bool bAutoClear = true)

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

2 C( f) O' b, K+ x, A

{ }

// no destructor needed

int __fastcall Add(T* Item)

{

return inherited::Add(Item);

+ I. d$ n' {) ]( l4 h4 N

}

. `- G1 g0 H: m4 [7 |; [

int __fastcall AddList(const TTypedList& List)

{

% F: |4 ]8 h: R) F( G3 Z) A& `

if(this == &List)

]; Z4 f! x/ ~$ i3 O

{

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

. o5 e! ^5 P1 \ Q' y5 c4 j

}

% ^$ F( |8 R7 ~, Z

if(FItemClassType != List.FItemClassType)

{

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

Type!");

4 g0 ~4 ^- q2 x' Q1 [8 E0 q

}

! r' Z, y O; j: A

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

{

Add(List.Get(i));

2 f4 E d* E' n9 r

}

return List.Count;

; i& e9 g& i9 `, g

}

virtual void __fastcall Clear(void)

3 w9 W: H- e6 X" o

{

$ J3 l3 `: C5 a4 o( H

if(FAutoClear)

% C0 F) |- X5 R3 n, F

{

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

{

7 H5 y6 r3 c0 R1 Q; o0 [4 P

delete Get(i);

}

8 i P( G' |9 V

}

0 q& b2 R9 z1 O6 Y

inherited::Clear();

9 {- b9 [ z5 k: i$ c$ W: A

}

! L7 y$ X) ?+ E) e- f2 p; J

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

. j* u: x. Q% ^( W, x

{

if(bAutoDelete)

4 V$ |. Q2 K7 y+ l8 ~, c8 l

{

delete Get(Index);

}

inherited:elete(Index);

}

T* __fastcall First(void) const

( ~5 Y) Q0 l, ^8 ~* [ V1 t( @

{

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

1 D/ }3 h0 q" x4 \& o# ?

}

, `% q9 Z# N* s+ J

int __fastcall IndexOf(T* Item) const

{

return inherited::IndexOf(Item);

4 a9 g) @, Z* T. n, P# p

}

void __fastcall Insert(int Index, T* Item)

{

+ K% ]+ d$ \) t$ P* O# V7 f

inherited::Insert(Index, Item);

}

6 {6 z$ R9 w$ T& V5 M G

bool __fastcall IsEmpty(void) const

! U, Q! q. Q9 i. h

{

return Count == 0;

}

, C; n1 N% w( \( c- G1 G

T* __fastcall Last(void) const

5 n+ z% d1 i% x, K/ I6 v- o) u

{

3 ?. h" e1 Z/ A+ ~5 Q( `7 t3 J

return (T*)inherited:ast();

4 b- \) i: y- ~( O7 b) u* y

}

: M) c' I/ S4 h8 K e, ?$ o

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

?( d8 p2 o+ ]9 R& ]7 G

{

int nIndex = inherited::Remove(Item);

" w! j3 Z9 A0 g5 j* `9 S# x, T: S

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

! \/ p: x5 n, \' Z# `

{

6 A# y$ P6 d+ K$ V6 a7 f

delete Item;

2 Q& }2 g! B; O

}

return nIndex;

}

void operator<<(T* Item)

{

Add((T *)Item);

" U( v4 ?; l; ?7 Y( |6 l; i

}

5 b% {9 D6 |+ g7 I; v( n

void operator<<(const TTypedList& List)

{

AddList(List);

}

' c; i$ f( P+ R( ]: W' |( P$ T

}; // end of TTypedList

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

#endif