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

韩冰

0 Q" Y6 r3 p1 R0 m1 |) `+ f: h* I

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

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

& b5 ^0 p/ F. K# o* f" x9 {# k( F

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

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

4 I( a" g8 D" C

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

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

! v$ p- t5 H0 R$ L; X

#include <classes.hpp>

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

template <class T>

class TTypedList : public TList

{

$ t+ ]& w$ l$ z, l( b3 C$ _

typedef TList inherited;

private:

bool FAutoClear;

1 I/ J, G& _% |- I

TClass FItemClassType;

protected:

$ }6 {3 n- f, r! ?1 ?4 Y

T* __fastcall Get(int Index) const

{

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

}

void __fastcall Put(int Index, T* Item)

{

& _7 A' P& x2 A

inherited:ut(Index, Item);

% }6 J0 ^& _6 l

}

public:

) V. e5 {# }- }" T

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

9 Q7 S4 C) L2 p8 V; H* V; t

public:

" o; R- c$ D9 N m

__fastcall TTypedList(bool bAutoClear = true)

7 }" E: l2 d5 ?$ E Y, B. ^" l

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

{ }

6 z4 y4 u" W- b) r- i1 h

// no destructor needed

int __fastcall Add(T* Item)

{

return inherited::Add(Item);

}

. }5 R/ r6 ^$ S. V

int __fastcall AddList(const TTypedList& List)

{

if(this == &List)

{

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

}

if(FItemClassType != List.FItemClassType)

: Q. u/ C! j m* M

{

5 ?4 `; V! Z" w% S; [. C* ?% v

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

Type!");

]+ ~" U- ?! }! K1 Y6 }

}

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

{

Y) N7 L, W6 e

Add(List.Get(i));

6 d2 i0 X$ u& R* [/ ]+ h

}

7 K$ i V; C# ]6 u2 i

return List.Count;

}

8 [$ Q! X5 {; `& n/ z$ g

virtual void __fastcall Clear(void)

. n+ b+ X" O% ?' u- o. } H7 T

{

if(FAutoClear)

' i8 a7 \ S- s# l9 j }

{

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

U+ }( ^( E0 O

{

delete Get(i);

* b2 |% ~: W# p1 N* X% v

}

% T c0 W( c! r9 ~

}

inherited::Clear();

}

Q8 {& L$ T8 r2 R/ c

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

: ^5 `2 N- @; ?3 W8 m+ K

{

if(bAutoDelete)

{

delete Get(Index);

8 s! z$ @$ I( ~

}

inherited:elete(Index);

}

. z0 u5 j( h# C6 b. x1 z5 m

T* __fastcall First(void) const

{

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

}

$ U5 g3 F! }* k) ]

int __fastcall IndexOf(T* Item) const

{

- m8 a- J$ w$ f( D

return inherited::IndexOf(Item);

}

void __fastcall Insert(int Index, T* Item)

{

inherited::Insert(Index, Item);

& V5 d' f% \" J" l- W

}

bool __fastcall IsEmpty(void) const

+ X+ E4 X3 s, R/ _* a) v1 l

{

2 i5 E& B" F# W: z9 C7 h K

return Count == 0;

: C O5 H3 {2 ~+ Q8 S

}

T* __fastcall Last(void) const

% m7 ~' q3 l* `) }

{

) A/ n v/ V* r( P2 ?6 u N1 y

return (T*)inherited:ast();

) l; Q+ I1 Z D% R* A! ]

}

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

{

int nIndex = inherited::Remove(Item);

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

{

' f! Z ?, h, U5 c v

delete Item;

}

* P# g. D h4 N5 H- A% O( E0 f

return nIndex;

; d, x p+ T9 Y; P

}

void operator<<(T* Item)

{

Add((T *)Item);

3 S, N5 S0 A# |; J

}

$ k- \# S3 }9 B, i5 Y" R

void operator<<(const TTypedList& List)

C( f. O( W" i+ L- j 5 o) T; t- ? N5 ~# d

{

; T" [' n4 d/ e; a

AddList(List);

}

: }) D3 U; o" H& h; R7 n: w& t

}; // end of TTypedList

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

#endif