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

韩冰

% n3 i9 v6 f; }) G4 G& D# I- y

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

% b) G' }6 O# I8 D+ X

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

3 _2 X. {1 K. ^% K. q5 L7 ^7 @

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

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

! L) `: b, b7 q& l- j

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

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

$ r! |0 k7 t, ]1 X

#include <classes.hpp>

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

template <class T>

/ n1 v6 o. Z9 V; ^: M' v9 A

class TTypedList : public TList

{

3 ~7 Q h4 M" r; V- B4 i1 D

typedef TList inherited;

private:

. A# e; A) p. J+ ~( K

bool FAutoClear;

- }6 r. }, c J

TClass FItemClassType;

protected:

& ]( l8 G5 \3 B# h( a6 a

T* __fastcall Get(int Index) const

{

0 A; H% t) j% k2 C2 L4 N" t$ O

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

}

* l3 b$ }) G6 e" I

void __fastcall Put(int Index, T* Item)

{

) t5 C, B1 {: M8 P# I' Z

inherited:ut(Index, Item);

}

public:

' Q# @! k1 Y w A) }& ^

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

1 A( S) D2 q& u) |

public:

__fastcall TTypedList(bool bAutoClear = true)

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

- p/ c2 n+ h% H0 P, `3 c

{ }

( ^3 u0 _0 e2 ^0 X: f+ y

// no destructor needed

int __fastcall Add(T* Item)

{

return inherited::Add(Item);

}

int __fastcall AddList(const TTypedList& List)

{

: o5 T" x0 F$ }. h2 c

if(this == &List)

{

1 R' X( X4 p1 X3 b8 x

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

2 j, ]* P' O. B4 Y

}

8 J8 Z q b& x

if(FItemClassType != List.FItemClassType)

4 b8 d! L% O$ U u" I$ {& a

{

! W3 [' m+ a+ D* I# n" D; G

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

. m8 C# x3 }9 c ]% S

Type!");

9 S! _7 h; P4 U& W

}

5 @ B7 D5 O* z; g( x

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

{

2 w. R' I2 T' }- s' t

Add(List.Get(i));

}

return List.Count;

}

virtual void __fastcall Clear(void)

{

if(FAutoClear)

{

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

* p5 N+ w2 T0 F0 t- T5 O

{

$ v$ i2 h. C8 Y& q- r+ l

delete Get(i);

C! _$ p9 k2 L6 F

}

6 p: W2 A6 ]" I7 \; f& ^+ S

}

inherited::Clear();

! u3 v. P! e9 c& \+ o

}

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

{

if(bAutoDelete)

# E' Q! e: @+ e( h1 T3 R& V' a! d

{

9 d4 \, H9 H" F' b! b

delete Get(Index);

}

inherited:elete(Index);

/ J! T. _5 C0 j5 @0 a

}

T* __fastcall First(void) const

{

; g: ]* K! b- X2 { E

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

}

int __fastcall IndexOf(T* Item) const

' h0 W4 C- Q; `! I# H% H( H

{

4 n! T( c) `2 E9 B( N' m3 y

return inherited::IndexOf(Item);

}

1 M6 Q2 y: F4 \9 n W, q( W# `

void __fastcall Insert(int Index, T* Item)

( J+ g Q* x e, O) Y( o5 d* V, v

{

inherited::Insert(Index, Item);

}

- r3 i# E, \( v# x* U6 Z

bool __fastcall IsEmpty(void) const

{

. }8 M5 C9 W+ B1 W

return Count == 0;

}

& e* a) [- T3 K( O' a& H

T* __fastcall Last(void) const

9 x2 R" k5 Z* [5 S$ d2 i: F+ L

{

return (T*)inherited:ast();

, Q: m: j7 q. z; S% y* E+ b, _2 K

}

- v4 [: _0 ?. [& O

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

{

- H: B/ R+ D+ |8 E: n. Y

int nIndex = inherited::Remove(Item);

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

5 A3 X5 f7 [+ i+ K

{

6 Y& h) Q+ A8 V( g1 f" e; p$ S$ t

delete Item;

}

% y: y( V1 V5 c' v& ]: X% |, a

return nIndex;

}

void operator<<(T* Item)

, r6 Q9 {; v2 n+ F: ^" h; P; ]4 w

{

3 ]& c: C- q+ a( m- v

Add((T *)Item);

}

) ?+ F* l; E* z3 W5 |* j

void operator<<(const TTypedList& List)

3 L, a' ]( W+ L2 f v

{

- a4 g) L( b1 V, S

AddList(List);

# P+ Q1 v |- |

}

: R% p0 a# x7 @) Y

}; // end of TTypedList

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

#endif