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

韩冰

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

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

. `, i) g u( J; `; e# c

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

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

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

. @0 i. j# @$ d% j" Q h3 S

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

# N4 K) B% t; |; G4 h- M0 v* G% A

#include <classes.hpp>

- a. [& _( P G/ c$ L

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

template <class T>

8 U* {" n; M" z9 I

class TTypedList : public TList

" g: U8 B8 }. B& }

{

7 n) ?0 F! @( u8 K% l3 Y' H9 [

typedef TList inherited;

private:

bool FAutoClear;

5 Z+ V, {& ]1 N. z8 f$ E" R

TClass FItemClassType;

+ F+ Y% a( ~, a6 X9 ], B: g; ?

protected:

) ^6 X: C; I: ]! D: i0 o9 g1 ^

T* __fastcall Get(int Index) const

& `8 e% g) h# \# z+ X' g' A

{

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

$ L4 [/ ~$ z- |' h% R5 E

}

6 o0 b( \8 V9 ]5 C% w; p6 r

void __fastcall Put(int Index, T* Item)

{

inherited:ut(Index, Item);

}

" J/ [( c7 D$ V$ T

public:

" X" T! O7 \8 t

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

% B/ O5 e) A* N& n

public:

__fastcall TTypedList(bool bAutoClear = true)

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

{ }

& n3 U' V* {* R, ?4 C* l. h, p

// no destructor needed

$ \0 R* W$ ~7 Z7 |5 k$ w

int __fastcall Add(T* Item)

{

) o4 f( J: }# u1 O, Q8 p

return inherited::Add(Item);

. Q% N+ `, f1 w* }6 e

}

int __fastcall AddList(const TTypedList& List)

! O1 u) A* e3 d2 G8 O7 d

{

if(this == &List)

{

8 N; ~. z: X3 B V4 B6 Z& H p

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

}

+ o' P d8 h+ t( U: f4 w/ f

if(FItemClassType != List.FItemClassType)

" o$ l: Q# b! \3 p( V

{

, Z, G# K& Z9 C8 B o

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

% a; o4 I0 y \, K: p7 H

Type!");

! k: M5 Z3 Q& i) n+ N: g8 m

}

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

{

Add(List.Get(i));

}

return List.Count;

}

virtual void __fastcall Clear(void)

{

9 }& B& Y7 w8 |' m

if(FAutoClear)

* y$ y8 e6 I/ x+ b& j* U1 ]

{

# Z3 e7 I8 n5 b# U

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

{

delete Get(i);

T1 M* K" n: T6 }* S. f9 ^3 L$ z. W

}

: C3 i% j7 R9 |2 d0 d1 J

}

inherited::Clear();

}

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

; t. c7 T& @7 i6 i+ ]- k

{

if(bAutoDelete)

7 x+ p9 d; U& Z7 S8 ^+ T( h5 U! S

{

' ^* n7 N. }; \

delete Get(Index);

}

inherited:elete(Index);

}

: l8 L2 w% l- j5 u( p+ c% u

T* __fastcall First(void) const

{

( L% G% h7 d3 ^1 D; w

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

1 n( e) c% l: K

}

int __fastcall IndexOf(T* Item) const

* Z" D0 |$ ]5 K; B/ X! k+ O* A' w

{

return inherited::IndexOf(Item);

) `/ I9 W; Y1 T: w

}

" U3 M' _8 Z3 t$ _6 x1 F7 C5 Y3 w

void __fastcall Insert(int Index, T* Item)

/ {( _3 y# t* }3 X. ?' o

{

" [- S" `1 z1 j" H0 q

inherited::Insert(Index, Item);

* S3 w7 d" J5 M2 I4 E0 a

}

! g2 b' M. _. w: w! j

bool __fastcall IsEmpty(void) const

$ w3 Y, R) }; J1 N9 d# ]1 x

{

$ ?4 b. _9 W9 o: p

return Count == 0;

- u3 J3 r ^: _% N( d7 y/ E

}

T* __fastcall Last(void) const

4 O( s1 `% r- c/ {" o

{

return (T*)inherited:ast();

}

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

+ s4 s8 Q% b9 @0 E

{

int nIndex = inherited::Remove(Item);

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

3 x6 a' C" P* {; ~5 {

{

delete Item;

- a5 W9 A4 r, H

}

* ]0 G( i: c. U9 a9 j# ]

return nIndex;

}

void operator<<(T* Item)

- F1 i! H/ A* a7 s( [

{

Add((T *)Item);

& ]; _( Z. C. }6 m. u. K, W# R

}

void operator<<(const TTypedList& List)

2 r' `) S3 ]5 B1 e) L3 x

{

AddList(List);

5 M9 v* e" T6 X9 v) g& \( h

}

}; // end of TTypedList

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

#endif