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

韩冰

8 x4 M' U7 _5 ~- L0 } M5 C2 ~

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

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

6 F' Y5 M5 V! x& b$ I

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

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

5 O* A# `) h$ N" x

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

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

#include <classes.hpp>

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

template <class T>

class TTypedList : public TList

{

[7 T& T& N, L! V1 U6 P

typedef TList inherited;

private:

; ]! P! n/ l* A1 `( ~' I6 v+ o" c2 l

bool FAutoClear;

TClass FItemClassType;

protected:

, D+ `/ i) u) ?

T* __fastcall Get(int Index) const

8 [4 V g- _$ |; W, H0 H

{

% G- {" N; \' J1 \0 V; f' z

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

3 h1 p7 j' q& s V

}

void __fastcall Put(int Index, T* Item)

{

inherited:ut(Index, Item);

1 I4 s8 x7 F k8 ~* e. T; ]4 W

}

public:

, V8 a* M% Y$ C! S

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

public:

2 Y3 \6 s2 h% u% B

__fastcall TTypedList(bool bAutoClear = true)

0 h5 g! q& S: N

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

! J5 L; ], [& r1 B5 L

{ }

1 w4 h7 z" W& ]1 H$ Z3 i5 ]& l

// no destructor needed

int __fastcall Add(T* Item)

5 J1 B1 i# L5 U. e& V1 B" j

{

' u! y* s F; t( c7 A z5 r

return inherited::Add(Item);

}

2 @1 l. ~$ ^+ j" M& I, E4 `

int __fastcall AddList(const TTypedList& List)

3 @7 A; ]0 c/ X

{

if(this == &List)

{

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

- K7 T" o9 z+ d5 |4 ~1 ~

}

4 g2 x) b. E. `: r7 \& t* m7 m

if(FItemClassType != List.FItemClassType)

! _2 W) f" S+ T2 q

{

7 n- P$ R1 q6 u# |" Y- e

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

! G0 R0 o. P* D, O3 K/ e

Type!");

! `7 b5 A& n- n

}

7 a" G8 \! Y& ^. I) @3 x

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

e" t5 h4 X8 f. p; o

{

/ u4 ~7 m2 `$ d# O# e5 o ^$ O7 A

Add(List.Get(i));

}

return List.Count;

0 W [" \" t9 y) U5 A3 y

}

# k/ i; x7 y) D- u+ b- O

virtual void __fastcall Clear(void)

{

if(FAutoClear)

{

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

. a8 ?0 \* {. |0 r

{

delete Get(i);

}

}

inherited::Clear();

: P. n9 d7 P: \( Z% {

}

; I7 `7 m- d1 k, Q0 [; ]# k; Y

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

{

if(bAutoDelete)

" i; W" @! K6 N# L

{

3 h k( l1 B# @' }! j9 h

delete Get(Index);

, W0 X( \# v6 L. A

}

2 k ]% [+ Z6 O& B* J& S" i$ p

inherited:elete(Index);

}

- D% M5 z6 @1 {, i2 M

T* __fastcall First(void) const

6 b) C( S2 h2 F3 P6 B( y

{

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

}

int __fastcall IndexOf(T* Item) const

! g/ V- x5 ^& V: V( ] D' m

{

return inherited::IndexOf(Item);

e" _" B1 k3 f

}

0 a' E8 N1 D- ]0 t

void __fastcall Insert(int Index, T* Item)

{

9 b% J' w; _2 H+ S

inherited::Insert(Index, Item);

; N/ \( X- ~6 ~

}

0 j$ V' X' {$ W6 y8 _5 t

bool __fastcall IsEmpty(void) const

$ Q8 b) B; `6 H3 _5 X9 Z

{

' p2 I6 Q; X. m7 d* Y7 H

return Count == 0;

}

T* __fastcall Last(void) const

{

return (T*)inherited:ast();

- k8 Q) W6 o6 w6 J, @8 f8 E6 a

}

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

X$ G! l! ?& h0 k$ t' B- U8 f: [' Q+ L

{

% F4 d) B( W! K$ n

int nIndex = inherited::Remove(Item);

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

{

( T- r# r+ Y2 m: i [8 y& P$ a

delete Item;

}

return nIndex;

}

' a* E2 v0 S2 h: p& @

void operator<<(T* Item)

{

, W/ `, \- m' G" U+ H$ K3 ?1 K

Add((T *)Item);

- q( g( q% ~0 K* [

}

void operator<<(const TTypedList& List)

- ]0 R1 \. {9 e

{

( i8 X6 T3 t8 Y. Z Y1 ~

AddList(List);

8 I4 ` l y3 _8 {! K0 m& D

}

* |5 W/ q# k/ B5 u

}; // end of TTypedList

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

. U$ I/ o" u7 p. ?- `; m

#endif