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

韩冰

* F |4 I& G6 n

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

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

4 o2 |9 |- E" X) j5 |

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

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

7 A8 r' e% T7 r0 W0 p' I7 a

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

2 \' J: o, U' x* D u+ j# C

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

#include <classes.hpp>

7 Y1 ~+ I- V- `3 i) L! y

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

template <class T>

- \7 _ m4 f) z" b" }

class TTypedList : public TList

{

" r, D& K9 @5 K5 U8 q- b8 O. p

typedef TList inherited;

private:

bool FAutoClear;

9 g, G4 m7 B8 B" A

TClass FItemClassType;

protected:

T* __fastcall Get(int Index) const

{

; c8 i4 [( h; |( l7 c: a+ G+ B

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

}

void __fastcall Put(int Index, T* Item)

b: _! A& N* D! \

{

r( P7 x" E2 C# n7 h

inherited:ut(Index, Item);

7 }: Q. ^, @7 S4 h

}

" n9 v' E- Y5 w) e

public:

, X6 o- [# q- {0 Y

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

public:

__fastcall TTypedList(bool bAutoClear = true)

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

1 e0 b& _& a2 |$ v: O& a

{ }

% ?7 `7 b: d# l" [$ t& A' e2 f

// no destructor needed

int __fastcall Add(T* Item)

' [1 o1 N z- _- J6 I; q! j' o- I; W

{

; s" P1 O! Q& Q1 S

return inherited::Add(Item);

: H2 J2 ^8 |- U- Q) s

}

int __fastcall AddList(const TTypedList& List)

* @- \9 I, ~3 `

{

if(this == &List)

+ K( g2 [9 m9 S s; r) z

{

0 i" k# R- P4 u

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

1 L* f' ~: V3 X

}

if(FItemClassType != List.FItemClassType)

7 M: L& }! P9 n9 [9 H$ d

{

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

Type!");

/ o+ p8 \% K' T/ O( x! F

}

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

{

( C& _: o. T! z6 Q& Q8 m, ?$ @/ V: d

Add(List.Get(i));

9 V! b- Y B4 Z* f# Z$ u

}

/ n' U: |" d3 `" u

return List.Count;

9 [$ p# u1 C) `, q$ Y9 e& k7 W

}

3 y) b; ]& |! F7 N5 h2 K7 s

virtual void __fastcall Clear(void)

{

3 p6 z7 c& A) Y! Q; O5 c3 ?, l8 F

if(FAutoClear)

7 c, r7 O! @% I0 a2 }1 k9 A( a$ ^

{

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

{

- s2 z6 `. s+ b$ t

delete Get(i);

3 D6 n& `! P; f' `

}

}

inherited::Clear();

}

' w9 \: F6 `; ?6 {* D+ L

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

{

7 B2 U# E C+ F4 Q+ l

if(bAutoDelete)

: m8 k* R$ u5 p' n x

{

delete Get(Index);

# o! w2 Q- O9 H C2 U

}

inherited:elete(Index);

3 ~' C1 ^) x$ \4 h

}

# g* y7 |1 N* x* E

T* __fastcall First(void) const

, k! A) u. B/ _8 T% b1 l( s

{

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

}

int __fastcall IndexOf(T* Item) const

; N4 G8 v) V6 r6 Y

{

return inherited::IndexOf(Item);

9 S1 P7 n8 R5 y8 c, [1 u" U

}

5 d+ ~0 y% H. k# A/ l8 Y

void __fastcall Insert(int Index, T* Item)

4 f+ ~/ {- Y# B" R: g1 F- d

{

+ e: A$ [+ V+ j# \: c& J* p

inherited::Insert(Index, Item);

}

! x4 o' q& r( Z7 q% C0 r# G, \

bool __fastcall IsEmpty(void) const

! b) t! Z! O: T( u! v" e% `

{

return Count == 0;

6 ]5 s; I: u- x& z

}

T* __fastcall Last(void) const

1 S# [9 U0 f/ i3 P4 M* h7 _

{

return (T*)inherited:ast();

6 `2 g! L: T( W; V

}

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

) Y/ Z) f! }" W$ ^/ b( R2 i3 l

{

3 w: n' J: `9 r, v. i9 @9 H

int nIndex = inherited::Remove(Item);

' h7 c6 w2 ^. w: ?1 l/ d+ o8 L( m

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

3 b6 Q7 z5 g0 S' M1 L& }

{

+ K; H* c6 e4 [2 W+ L2 G

delete Item;

}

return nIndex;

8 [. i# f6 D) j1 z( b! u# }

}

: e8 ]/ B; ]7 R1 n2 d5 Y9 R

void operator<<(T* Item)

{

Add((T *)Item);

}

4 o- U% |% r; K8 A7 A% R# t7 w

void operator<<(const TTypedList& List)

{

AddList(List);

}

. H$ Q, j* Q7 _3 f

}; // end of TTypedList

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

) z3 m. e8 t/ |& v4 a) l; H) t

#endif