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

韩冰

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

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

3 q" m& K4 d4 Y5 [3 h! @: K# m

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

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

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

! i+ H0 L/ M4 s! m* k5 I# ?. M; D

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

3 } D1 G4 n% M+ A6 F" g/ o

#include <classes.hpp>

0 g$ W7 b7 L; p9 u( w

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

template <class T>

: Z2 s) U5 j4 i2 b* y, k$ C

class TTypedList : public TList

5 P* o+ i% p! {7 D: S2 a

{

( B C6 ?* ?/ ] \$ A( K" R

typedef TList inherited;

5 }( ^- P) c5 Z" F

private:

bool FAutoClear;

TClass FItemClassType;

4 a- |. `2 O8 t: G

protected:

) T% x1 h8 m- _( O2 O

T* __fastcall Get(int Index) const

. I. u- U+ R3 ?: m

{

; I) k1 S7 l* M$ }/ F. }! ^

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

9 T3 |5 @9 i- O, ~

}

: ?& B0 g# h$ a8 K7 T' t

void __fastcall Put(int Index, T* Item)

{

, s1 d, G& E% E

inherited:ut(Index, Item);

}

: a' Q [+ ^+ i0 j. q; L

public:

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

public:

! p; e# v; M. S( g n T/ ~3 }

__fastcall TTypedList(bool bAutoClear = true)

2 s8 \: H8 u* H* ], i4 j" ~1 n. |

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

{ }

// no destructor needed

2 x# y7 e$ S5 s" t3 D) H

int __fastcall Add(T* Item)

+ |+ G( d8 ~# c9 g- q7 o

{

) p( L; n8 f. J9 i7 W, `

return inherited::Add(Item);

8 `4 Y4 I* b! J' ^- C% Y, j" L

}

- C, x! {, q. h% Z

int __fastcall AddList(const TTypedList& List)

# m% c# i: s( ?- N1 V

{

6 v) D# `% n7 `5 u R1 J

if(this == &List)

' k5 W+ `8 q ^( I

{

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

}

2 r8 K z* G, `! e8 B' b

if(FItemClassType != List.FItemClassType)

{

2 A/ y2 K) I" t: ]# E

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

Type!");

& v6 E( n8 Y- T7 p" ~. j

}

T9 P! m: R) i1 a

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

{

8 K9 d" G* D/ E

Add(List.Get(i));

}

3 g1 W, q$ y4 o; _1 Z' R

return List.Count;

6 }& {* P0 u/ w% Q

}

& e* j/ {/ B. o/ U) m

virtual void __fastcall Clear(void)

{

; X2 g# m- A+ _4 L% P! l) Q4 S

if(FAutoClear)

{

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

{

delete Get(i);

3 A" Z- n1 K5 T5 ? S

}

6 ^ u4 _3 ^ N

}

! o# x, R3 G, I

inherited::Clear();

}

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

+ m y6 }# ~- i/ v, ~7 L

{

6 A% p2 H( P0 ]4 J# g& g

if(bAutoDelete)

{

7 I6 s8 d/ U; j3 f

delete Get(Index);

}

$ K5 A, k0 t k6 o8 u* A: f

inherited:elete(Index);

' [5 S' P) E) A. L6 [

}

T* __fastcall First(void) const

3 X* v* X5 |1 {' ^" |5 k

{

7 V5 [8 k' R+ u( V% D

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

}

int __fastcall IndexOf(T* Item) const

! X* l- W+ C3 |) k* r) g$ g5 [

{

* j; M0 l1 h4 d) b7 `% x

return inherited::IndexOf(Item);

: `. U. D& E) [: W

}

; K) r- D, h) p( o, t3 L9 s! r

void __fastcall Insert(int Index, T* Item)

# n" W& q" k' O' |

{

inherited::Insert(Index, Item);

}

bool __fastcall IsEmpty(void) const

N! O# H R- l6 S- L3 F

{

return Count == 0;

}

T* __fastcall Last(void) const

{

) t& D+ I/ h+ U4 x

return (T*)inherited:ast();

$ W6 b( L- D. M. S5 y% L6 G$ s/ h+ C

}

9 g6 M" U8 j) L# n) L/ Q4 u

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

' Z2 g+ I6 {' i; c k+ \7 b

{

% h6 E2 ~! M' v, |& l

int nIndex = inherited::Remove(Item);

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

0 E4 W! j7 q- e9 l+ [( L+ ~

{

6 \3 a6 S$ J9 G! T

delete Item;

3 Z/ Q# V% r' o. U1 X

}

' v1 H( y% W2 K/ R+ ?

return nIndex;

}

7 x# A7 O5 u4 Y' T5 K

void operator<<(T* Item)

{

- U2 o( q9 J* y3 G) F1 Y- S2 H k

Add((T *)Item);

& `$ H* v& U: S& a" Q

}

1 X" E1 s" K8 i

void operator<<(const TTypedList& List)

{

5 @) v4 r3 }: D( c

AddList(List);

}

}; // end of TTypedList

9 f/ K* ^! N6 ^$ w3 X$ p

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

5 q. S5 ?% G5 D/ }# ^2 T; A) k o+ F

#endif