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

韩冰

5 [3 t. j" I0 \' u* ?$ w) V. T; [

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

: U6 F; Y. T' P7 n: ?4 h6 F' k

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

/ N E* ?8 {- v; [

" J' Z2 S7 T1 i

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

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

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

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

#include <classes.hpp>

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

5 S+ ?; ~2 ]- h

template <class T>

7 v" T8 T7 ^3 W# O! W

class TTypedList : public TList

{

typedef TList inherited;

, ?/ f% b/ h" R- z0 |

private:

bool FAutoClear;

: R. B3 y: f! r2 `: I/ V% j: k

TClass FItemClassType;

. ~$ v+ y3 B) p2 g1 K. t$ c+ @

protected:

; q* u! ]* \9 L5 X

T* __fastcall Get(int Index) const

{

4 U5 z- R$ c- V0 Q' S0 }* C

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

}

- g4 x# o7 \& f) U. b2 S% [- m

void __fastcall Put(int Index, T* Item)

6 i+ f+ `) A) }

{

1 c% V7 h" j" {% H x

inherited:ut(Index, Item);

% ~( B0 L- _7 W# m: C% C

}

) |' J' O( G6 F) S7 q9 P& }

public:

8 ]- O! `* I9 g1 {; U3 i' J

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

public:

! s$ X; E* ?7 U! P+ S1 |/ y

__fastcall TTypedList(bool bAutoClear = true)

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

* k) {6 R% O' L# D5 @5 I, K8 d

{ }

// no destructor needed

int __fastcall Add(T* Item)

{

return inherited::Add(Item);

* ?9 ]. N: S9 z* @2 J! |4 A

}

5 I7 E0 M9 b) y! ^

int __fastcall AddList(const TTypedList& List)

{

! w7 U. l6 z/ N& T( h9 ]

if(this == &List)

{

H6 |: i4 v: |0 q& \0 U" ?

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

+ Q' u/ C5 X9 ?* ~( X9 q

}

" w p* \7 d b

if(FItemClassType != List.FItemClassType)

7 {9 Z5 M4 o1 H* A1 _/ q

{

. q( U/ G. F3 ]2 x3 y j/ E) {

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

Type!");

}

5 x" h1 l: R8 T& v; m1 H

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

: e! U x3 v3 w, X

{

8 b8 l J/ |, f. `8 v7 w/ E

Add(List.Get(i));

}

return List.Count;

}

& Q9 Q/ {5 @0 q# B

virtual void __fastcall Clear(void)

- P( M5 _6 C. l( Q) y

{

' R9 v9 t9 C( ?; N% {

if(FAutoClear)

) T z* \3 @8 W; L. M% ^

{

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

7 b" C. {! x1 Z+ C1 j

{

& x8 v% ?0 a5 ~) w! X" p

delete Get(i);

' W( k) U& o% J- B! ^

}

! _. c* D5 o: u; G3 A! E

}

- n1 ?/ n6 H3 l+ }+ Y) l- g

inherited::Clear();

}

* A1 d% f- ]: X% a; `- w) T

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

% O N8 h( F& I( J

{

if(bAutoDelete)

5 t. {' h5 G) l/ D6 r

{

( _5 v3 G$ d4 y4 q4 `* H, o! E

delete Get(Index);

: {6 X, @8 y; h/ @6 v0 `

}

inherited:elete(Index);

6 b I- b5 j/ l/ O

}

: Q1 X; I. S+ S" G# X7 I

T* __fastcall First(void) const

+ W, L- P0 R' f) t

{

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

}

int __fastcall IndexOf(T* Item) const

{

return inherited::IndexOf(Item);

}

void __fastcall Insert(int Index, T* Item)

6 J! r: E# t( x) x l/ J4 ~

{

inherited::Insert(Index, Item);

( |% I% |+ c5 P5 i% G, w

}

bool __fastcall IsEmpty(void) const

{

8 R# r, P/ k. G) P* Q, q1 W

return Count == 0;

}

T* __fastcall Last(void) const

{

- \% w% J6 S7 U& y

return (T*)inherited:ast();

, j0 G. z; e+ E9 G: g' x3 t

}

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

{

6 e' ^4 ]1 p( } B3 e& L

int nIndex = inherited::Remove(Item);

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

{

delete Item;

}

0 I) m- E m% o2 b) Y' b8 T

return nIndex;

}

8 W) i' R$ s1 P/ c# x- N D

void operator<<(T* Item)

/ a, b% z. c# |2 M8 O

{

Add((T *)Item);

. _7 X0 [( j, x F$ T7 ^

}

# ~6 ~9 |& x9 v' j/ ^! ]+ R- {0 s- J

void operator<<(const TTypedList& List)

) F5 l" J5 i) H! l! Y) k! R4 f

{

AddList(List);

, A) m+ _/ f2 j+ D# L/ h, K. K# S

}

}; // end of TTypedList

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

- P$ Q4 r4 m3 M7 ]' T" Z6 C

#endif