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

韩冰

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

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

& u4 d* D- q: P, b$ _! u! a+ e

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

" O, a# M; v0 w; B. B) Z

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

. K2 N+ h' x) z! m

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

; d, [. l5 {' S' ?1 m% j* b' I

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

#include <classes.hpp>

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

template <class T>

- V4 @) M3 r0 X

class TTypedList : public TList

{

& h, H5 G. [' ^; H' }' }

typedef TList inherited;

5 [3 [7 X1 Q0 o; b- q/ E0 c

private:

bool FAutoClear;

/ e0 b5 X1 ?. n+ R @ D

TClass FItemClassType;

2 }0 V. r- ?% i

protected:

T* __fastcall Get(int Index) const

{

) O7 d6 w1 z3 X m, T

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

}

+ M: H2 c9 j6 W8 X1 E3 r- k/ Y

void __fastcall Put(int Index, T* Item)

R7 t5 `7 Q5 o ^! Z$ v8 Z+ ^" }: \

{

3 f; O& _& B+ g5 J

inherited:ut(Index, Item);

}

+ W1 Y. g/ w9 X

public:

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

public:

5 N t {5 _$ e" ] o. q/ [+ i/ M

__fastcall TTypedList(bool bAutoClear = true)

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

9 m! q8 i0 V7 z% y

{ }

& e: D; Y* [( N7 s* \

// no destructor needed

int __fastcall Add(T* Item)

* f+ p' j( W% d$ J7 J

{

: M" m( F7 R% \# Q

return inherited::Add(Item);

% E6 W9 e/ q/ Q# l+ a

}

P, d: x3 A4 I) ^/ L6 d. K( `

int __fastcall AddList(const TTypedList& List)

{

if(this == &List)

, I5 B- a% Y6 u7 A- @) J% i1 f

{

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

; u' i. c! {5 E0 t/ B7 t4 {, u

}

if(FItemClassType != List.FItemClassType)

9 |' X6 \$ v6 ~; y" G- g8 f

{

+ L" |; |' D; v% Y$ M7 I

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

Type!");

% P' ]; u$ g+ z5 Q

}

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

/ Z1 ^5 `/ U: k0 F# k1 P; v8 K w

{

Add(List.Get(i));

7 P" h0 V, ^# H) W* i) j. M

}

return List.Count;

}

virtual void __fastcall Clear(void)

6 e: R$ N, V: {9 }6 n) W2 \

{

! ^6 m* \# F+ _) j& [

if(FAutoClear)

{

. l7 Z4 [' V' R f

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

{

delete Get(i);

}

}

`0 D0 Z& s# z

inherited::Clear();

}

/ d! u) {- b' R0 N E

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

( _) X% B( ]6 z7 d# f

{

( ^9 s* x( k3 r* I) |) u5 f

if(bAutoDelete)

* t8 T+ i5 K, W+ L J8 \2 k9 ?

{

/ Q# J. R e( p9 ^0 V4 \

delete Get(Index);

}

6 h" x) P% l* B0 K* |: o G& ?

inherited:elete(Index);

}

T* __fastcall First(void) const

& s! G! O% K0 o2 @/ {

{

; k" R, S% {! n! E `

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

}

int __fastcall IndexOf(T* Item) const

{

`0 M4 @" L$ M) p0 ]) n

return inherited::IndexOf(Item);

}

void __fastcall Insert(int Index, T* Item)

{

1 E6 d [5 x9 @/ O; `

inherited::Insert(Index, Item);

* e5 S2 m, x% c K5 n* K9 D# k

}

/ q7 o. G. l P( p. d O

bool __fastcall IsEmpty(void) const

{

return Count == 0;

% a$ E8 ^8 U7 f4 l2 D

}

% p( e, m& V- S# N. | R6 Y

T* __fastcall Last(void) const

8 g7 m3 B9 n- @3 p! w" O; \( x

{

return (T*)inherited:ast();

% E" z6 u" l+ Q

}

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

{

3 S& B' I' d+ e

int nIndex = inherited::Remove(Item);

& i1 ?( X% ]- {+ s- a, O- {9 t& F

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

{

delete Item;

8 p# v7 o+ H8 W5 s7 F, K) o, A

}

* @/ ^+ X, [, U4 d7 O% j

return nIndex;

8 D1 A9 P. C' `2 e" h2 k5 ^

}

; ?# l. T% H4 m0 S- y3 A& d

void operator<<(T* Item)

. T0 l* }+ b# ]# E7 m1 z& x

{

" R/ ~3 P, r- T- a( D9 M

Add((T *)Item);

}

! P7 {0 l- c+ X% J9 E

void operator<<(const TTypedList& List)

3 B/ P% U9 E' f& e5 t0 K

{

AddList(List);

}

3 O$ v" L- [9 l5 }! B0 W

}; // end of TTypedList

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

4 o5 P6 b% y) b y

#endif