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

韩冰

- f0 u, f. P4 r/ w: w

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

$ g/ `( R$ X/ k# @ g9 I

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

& J3 t8 F$ \. x! f5 a$ |' j U9 R" h; q

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

0 l0 G; q- ?9 E2 k# U0 u+ \

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

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

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

#include <classes.hpp>

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

4 v% f% q h" P* |) k5 ~- M

template <class T>

class TTypedList : public TList

; a8 l( N) Y; X; X! w; p$ i

{

typedef TList inherited;

1 c: i8 n" H5 I; ?0 s. S

private:

/ h. q0 o3 z% i5 A0 u

bool FAutoClear;

TClass FItemClassType;

protected:

T* __fastcall Get(int Index) const

{

! ^' f. w. K4 D2 S

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

}

3 I+ Q! D. I: B" U% _

void __fastcall Put(int Index, T* Item)

) w0 z' G2 }( v% j

{

inherited:ut(Index, Item);

}

) ~6 O$ B: A& r* b. K$ B G

public:

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

public:

__fastcall TTypedList(bool bAutoClear = true)

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

2 v9 G* Z% d0 M9 V4 _. h7 c+ f3 w7 |

{ }

8 @; L& Z+ `5 h2 C

// no destructor needed

int __fastcall Add(T* Item)

{

return inherited::Add(Item);

}

int __fastcall AddList(const TTypedList& List)

" N- [: Z7 }* e/ k( g$ e6 ~0 n

{

: t' ?- \: ` c& ?5 q$ g9 R1 X

if(this == &List)

{

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

}

if(FItemClassType != List.FItemClassType)

{

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

9 d6 b' R: E% a! m

Type!");

}

5 [+ n" _2 X' m" F; R

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

{

3 ?; a3 V; C. I6 C

Add(List.Get(i));

- o4 S4 m! M0 y3 v$ Q6 b, ]; v/ I

}

return List.Count;

, W) O) t* `' k, R% x6 `

}

5 y! ?- m/ C7 Q2 U

virtual void __fastcall Clear(void)

$ o6 K, @+ P. ~+ `

{

( t4 D6 o( K/ Y/ N4 N$ G { @

if(FAutoClear)

{

" D( ~% s2 N, [) r2 D8 ?' d

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

{

% \7 }5 a; N! P5 o! p9 u# P

delete Get(i);

}

4 S& F- T1 T E& Q0 R6 L0 l" X

}

& N# I9 H! P9 C" g( g

inherited::Clear();

- Z7 h6 ^3 }$ f1 F

}

& K0 w$ l/ A' O( T2 n7 h

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

{

if(bAutoDelete)

{

2 j) o2 R+ h$ J5 w# A* r% T3 j

delete Get(Index);

}

# }8 N% g# H& \0 t

inherited:elete(Index);

}

T* __fastcall First(void) const

& j( ]: m6 E. ]

{

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

}

int __fastcall IndexOf(T* Item) const

' a7 w' u& E# O, @1 k; T' z

{

' W& z3 h- r8 N$ H

return inherited::IndexOf(Item);

}

void __fastcall Insert(int Index, T* Item)

{

9 @# ]5 A" u; E3 m1 F6 y

inherited::Insert(Index, Item);

}

bool __fastcall IsEmpty(void) const

! H! l% M7 D f

{

; }5 ^' }: e7 `. U3 n& w+ @" {

return Count == 0;

3 @; b _2 I) k c' V; ]2 K

}

0 U0 m$ n% W4 E( r% ^4 L

T* __fastcall Last(void) const

% X: ]+ y# V) k/ Y" _

{

2 N; X% z0 ]9 ^5 ^1 O9 u

return (T*)inherited:ast();

9 o O& g5 g1 Y/ ~: \8 b7 ^9 _

}

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

{

: v. u9 _' d( n6 d

int nIndex = inherited::Remove(Item);

. L7 T0 J5 k; |7 J

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

+ M6 V \0 x9 F

{

; l ?( Y5 [# n# c) Z

delete Item;

" [1 E/ y( e/ L; u

}

return nIndex;

+ j: W$ m' h* } \" m5 n

}

void operator<<(T* Item)

{

3 E6 z5 f- ~8 {

Add((T *)Item);

0 e! L4 [. \" u C& y" w1 y" a

}

1 b' M Z& [; x: o! U+ X; w

void operator<<(const TTypedList& List)

. n/ c3 n8 O( z/ C1 q( Q

{

AddList(List);

}

}; // end of TTypedList

8 _* p. L+ G2 i9 ]; ]) V- Q7 K

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

#endif