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

韩冰

! U( p- Y: L* T0 O3 P9 m5 C

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

# [$ e9 Q$ m& @- p2 T; b

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

& q# G I9 e- V9 \; X. ^5 Q, q9 \

# J4 W7 X6 g3 _& x# o( Z% o

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

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

' `! R/ \+ I8 q

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

5 t F4 L: n/ H/ I7 f0 D$ m$ K

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

#include <classes.hpp>

3 Q" k5 E! _: S5 ^# _& @

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

9 {2 J2 r5 ]5 b( `% D

template <class T>

0 n8 G. x, t A( k; Y+ s/ D

class TTypedList : public TList

* E& K8 M0 S4 m

{

typedef TList inherited;

private:

bool FAutoClear;

4 i& O2 P p! o, t) m( b& J

TClass FItemClassType;

protected:

T* __fastcall Get(int Index) const

{

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

}

void __fastcall Put(int Index, T* Item)

{

inherited:ut(Index, Item);

}

5 }5 z5 i. M; V3 @

public:

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

* h# K6 | k0 p

public:

5 ^8 S! L: R2 \7 |. h4 r, H+ ^

__fastcall TTypedList(bool bAutoClear = true)

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

# ?$ Q: _; k7 W1 S0 f5 O1 q

{ }

// no destructor needed

8 X) D+ N5 P( q! v1 E

int __fastcall Add(T* Item)

{

7 b( Z/ s8 p2 A8 v6 z- z0 Z

return inherited::Add(Item);

}

7 W, {; o: L% M5 m4 ~( [

int __fastcall AddList(const TTypedList& List)

{

+ f9 O$ S$ ~3 Y) M1 Z3 w2 f

if(this == &List)

/ k' v9 I/ g5 N

{

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

}

# g" } D) Q# G0 A! p- d

if(FItemClassType != List.FItemClassType)

5 j* [: c+ w9 ^

{

, [( @% N3 A9 }9 E& L; p" G

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

5 I) H2 H' f p3 W$ |

Type!");

& a% z1 C1 I2 p% ]. P5 ~4 r

}

0 Z3 B* V( P5 H, z" _

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

5 L ~6 G* z1 P# ?

{

8 C w* D0 i* w! b4 p

Add(List.Get(i));

}

' e) w1 w' Y% ~4 K1 d9 ^7 x

return List.Count;

}

virtual void __fastcall Clear(void)

4 Q+ I( L4 G% }+ b1 u

{

; W& d, ~- p/ J4 z1 i3 M) j4 B

if(FAutoClear)

; k5 Q) |% h$ B

{

/ q' k0 a2 f1 B1 c2 f

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

- }7 d5 P& v' c( X9 F3 N# b6 V

{

delete Get(i);

}

2 n; O" e, L# [2 Q

}

$ J f: Z9 S( ?7 Y5 L% b! g9 m* C

inherited::Clear();

3 {$ E3 V) A! K) v

}

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

{

$ _4 m6 u7 j; Z0 t! i; ~

if(bAutoDelete)

{

delete Get(Index);

}

inherited:elete(Index);

}

T* __fastcall First(void) const

{

: j( ?( d5 A- r' |4 k7 P

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

# U2 B3 i$ P3 f! q1 G

}

% Q9 b5 p% t9 x' d4 \8 ?

int __fastcall IndexOf(T* Item) const

6 S. Y/ C0 L6 ~+ `$ y9 z

{

return inherited::IndexOf(Item);

}

! }2 p+ O8 p0 L

void __fastcall Insert(int Index, T* Item)

+ U% i( f9 {; Q7 @6 A' W! n

{

inherited::Insert(Index, Item);

}

bool __fastcall IsEmpty(void) const

2 K2 V! ]6 G" e# I

{

. c+ G$ f" ~9 X5 Y8 d% }4 O8 `1 z

return Count == 0;

}

T* __fastcall Last(void) const

" w! L7 |8 h1 Q* l2 q

{

# C, F5 Y$ O+ q: F

return (T*)inherited:ast();

4 K8 N* V# f2 a# `8 S

}

7 Z8 i. M5 v1 j' n' h6 _+ e

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

7 M6 \, N: N. ?9 E- }8 T: ~

{

int nIndex = inherited::Remove(Item);

. w' g# e% Q, r

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

{

delete Item;

}

return nIndex;

}

6 I& w2 L) C8 Y# ], n

void operator<<(T* Item)

) h I3 G8 k$ i1 _4 U4 [+ a

{

! X5 B: B: o3 h+ m) P- y

Add((T *)Item);

}

void operator<<(const TTypedList& List)

8 u* Q# T! @. t E

{

" h+ ?! r, e5 Z! m% U W. C$ F9 C

AddList(List);

}

1 y% f6 v2 W& m: W7 q

}; // end of TTypedList

* m/ g3 h0 d+ G: G( h3 J0 m* O

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

#endif